#include #include #include #include #include #include /* mux- */ #include /* -System V */ #include #include #include #include #include #include #include #include #include #include "../inc/config.h" #include "../inc/isys_com.h" #include "../inc/type.h" #include "../inc/lcd_task.h" #include "sony_i2c.h" #include "sony_cxd6801gl.h" #include "sony_app_glue.h" #include "sony_common.h" #include "sony_example_common.h" #include "atsc/sony_integ_atsc3.h" #include "atsc/sony_demod_atsc3_monitor.h" #include "atsc/sony_demod_atsc.h" #include "tuner/terr_cable_ascot3/sony_tuner_ascot3.h" #include "tuner/terr_cable_sat_freia/sony_tuner_freia.h" #include "sony_demod.h" #include "isdb_terr/sony_integ_isdbt.h" #include "isdb_terr/sony_demod_isdbt_monitor.h" #include "sony_demod_driver_version.h" #include "atsc/sony_demod_atsc_monitor.h" #include "atsc/sony_integ_atsc.h" #include "stdio.h" #include "atsc/sony_atsc3.h" #include "atsc/sony_demod_atsc3_monitor.h" #include "../inc/isys_config.h" extern u8 g_tun_plpnum; extern sony_atsc3_plp_list plpinfos; extern pthread_mutex_t mux_i2c_tuner; extern int fd_i2c_tuner; static sony_driver_instance_t atsc_driver; extern void update_tune_info(void); static u8 conv_sony_pilot_dx_array[]={ 3,4,6,8,12,16,24,32 }; // Global variable to store detected tuner type static tuner_chip_type_t g_detected_tuner_type = TUNER_TYPE_UNKNOWN; /** * @brief Auto-detect tuner chip type by probing demod I2C addresses * @param pI2c Initialized I2C interface * @return Detected tuner chip type */ static tuner_chip_type_t detect_tuner_chip_type(sony_i2c_t *pI2c) { uint8_t test_data = 0; sony_result_t result; printf("\n===========Auto detecting tuner chip type===========\n"); if (!pI2c) { printf(">>> ERROR: I2C interface is NULL!\n"); return TUNER_TYPE_UNKNOWN; } // Try CXD6821 (FREIA) first - demod I2C address 0xC8 // SLVX address = SLVT + 4 = 0xC8 + 4 = 0xCC printf("Trying TUN FREIA with demod I2C addr 0xC8 (SLVX=0xCC)...\n"); result = pI2c->ReadRegister(pI2c, 0xCC, 0x00, &test_data, 1); if (result == SONY_RESULT_OK) { printf(">>> Detected FREIA tuner - demod I2C=0xC8\n"); return TUNER_TYPE_CXD6821; } // Try CXD6801 (ASCOT3) - demod I2C address 0xD8 // SLVX address = SLVT + 4 = 0xD8 + 4 = 0xDC printf("Trying TUN ASCOT3 with demod I2C addr 0xD8 (SLVX=0xDC)...\n"); result = pI2c->ReadRegister(pI2c, 0xDC, 0x00, &test_data, 1); if (result == SONY_RESULT_OK) { printf(">>> Detected ASCOT3 tuner - demod I2C=0xD8\n"); return TUNER_TYPE_CXD6801; } printf(">>> ERROR: No tuner chip detected!\n"); return TUNER_TYPE_UNKNOWN; } /** * @brief Get demod I2C address based on tuner type * @param type Tuner chip type * @return Demod I2C address (SLVT) */ static uint8_t get_demod_i2c_addr(tuner_chip_type_t type) { switch(type) { case TUNER_TYPE_CXD6821: return 0xC8; case TUNER_TYPE_CXD6801: return 0xD8; default: return 0xD8; // Default to CXD6801 } } sony_result_t sony_InitializeDriver(sony_driver_instance_t *pDriver, uint8_t enableLNBC) { sony_result_t result = SONY_RESULT_OK; sony_demod_create_param_t createParam; uint8_t enableTuner = 1; if (!pDriver) { return SONY_RESULT_ERROR_ARG; } /* Add I2C initialization code for target environment */ i2c_drv_imx_init(&pDriver->i2c); printf("I2C driver initialized\n"); /* Auto-detect tuner chip type if not already detected */ if (g_detected_tuner_type == TUNER_TYPE_UNKNOWN) { g_detected_tuner_type = detect_tuner_chip_type(&pDriver->i2c); if (g_detected_tuner_type == TUNER_TYPE_UNKNOWN) { printf("ERROR: Failed to detect tuner chip type!\n"); return SONY_RESULT_ERROR_NOSUPPORT; } } /* Set demod I2C address based on detected tuner type */ createParam.xtalFreq = SONY_DEMOD_XTAL_24000KHz; /* 24MHz Xtal */ createParam.i2cAddressSLVT = get_demod_i2c_addr(g_detected_tuner_type); createParam.tunerI2cConfig = SONY_DEMOD_TUNER_I2C_CONFIG_REPEATER; /* I2C repeater is used */ createParam.atscCoreDisable = 0; /* ATSC 1.0 core enable */ printf("Using demod I2C address: 0x%02X\n", createParam.i2cAddressSLVT); /* Create tuner driver based on detected chip type */ if (g_detected_tuner_type == TUNER_TYPE_CXD6821) { /* CXD6821: Use Sony FREIA (ASCOT4) tuner */ printf("Creating FREIA tuner driver for 6821...\n"); result = sony_tuner_freia_Create(&pDriver->tuner, 0xC0, &pDriver->i2c, SONY_ASCOT3_CONFIG_IFAGCSEL_ALL1 | SONY_ASCOT3_CONFIG_REFOUT_600mVpp | SONY_ASCOT3_CONFIG_LOOPFILTER_INTERNAL, &pDriver->freia); if (result != SONY_RESULT_OK) { printf("sony_tuner_freia_Create failed. (%s)\n", Common_Result[result]); return result; } printf("FREIA tuner driver created successfully\n"); } else if (g_detected_tuner_type == TUNER_TYPE_CXD6801) { /* CXD6801: Use Sony ASCOT3 tuner */ printf("Creating ASCOT3 tuner driver for 6801...\n"); result = sony_tuner_ascot3_Create(&pDriver->tuner, SONY_ASCOT3_XTAL_24000KHz, 0xC0, &pDriver->i2c, SONY_ASCOT3_CONFIG_IFAGCSEL_ALL2 | SONY_ASCOT3_CONFIG_REFOUT_600mVpp, &pDriver->ascot3); if (result != SONY_RESULT_OK) { printf("sony_tuner_ascot3_Create failed. (%s)\n", Common_Result[result]); return result; } pDriver->ascot3.xosc_cap_set = 0x28; /* For optimization */ printf("ASCOT3 tuner driver created successfully\n"); } else { printf("ERROR: Unknown tuner type!\n"); //return SONY_RESULT_ERROR_NOSUPPORT; /* CXD6821: Use Sony FREIA (ASCOT4) tuner */ printf("still try 6821...\n"); result = sony_tuner_freia_Create(&pDriver->tuner, 0xC0, &pDriver->i2c, SONY_ASCOT3_CONFIG_IFAGCSEL_ALL1 | SONY_ASCOT3_CONFIG_REFOUT_600mVpp | SONY_ASCOT3_CONFIG_LOOPFILTER_INTERNAL, &pDriver->freia); if (result != SONY_RESULT_OK) { printf("sony_tuner_freia_Create failed. (%s)\n", Common_Result[result]); return result; } printf("FREIA tuner driver created successfully\n"); } /* Construct sony_integ_t and sony_demod_t instances */ /* If the driver need not to control tuner, NULL can be used. */ /* If the driver need not to control LNBC, NULL can be used. */ result = sony_integ_Create (&pDriver->integ, &pDriver->demod, &createParam, &pDriver->i2c, (enableTuner ? &pDriver->tuner : NULL)); if (result != SONY_RESULT_OK) { printf ("sony_integ_Create failed. (%s)\n", Common_Result[result]); return result; } //printf("sony_integ_Create success\n\n"); /* * Initialize devices. (demod, tuner, LNBC) * Following this call the driver will be in SONY_DEMOD_STATE_SLEEP state. * From here you can call any Sleep or Tune APIs. * 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_Initialize (&pDriver->integ); if (result != SONY_RESULT_OK) { printf ("sony_integ_Initialize failed. (%s)\n", Common_Result[result]); return result; } printf("sony_integ_Initialize success\n\n"); return result; } /***************************************************************************** * Function : sony_cxd6801_tslock_atsc3p0 * Description : * Input : sony_demod_t * p_demod uint8_t *p_tslock_state uint8_t *p_sync_state u8* p_alp_lock_all u8* p_plperr 0:all PLPs are founded, 1:not found * Output : None * Return : * Others : * Record * 1.Date : 20230713 * Author : Shu.Wang * Modification: Created function *****************************************************************************/ int sony_cxd6801_tslock_atsc3p0(sony_demod_t * p_demod, uint8_t *p_tslock_state, uint8_t *p_sync_state, u8* p_alp_lock_all, u8* p_plperr) { sony_result_t result = 0; const char *lock_str[] = {"No", "Yes"}; const char *unlock_str[] = {"Not Detected", "Detected"}; uint8_t syncState = 0; uint8_t alpLockState[4] = {0}; uint8_t alpLockAll = 0; uint8_t alpUnlockDetected = 0; sony_demod_lock_result_t lock = 0; int tslock = -1; result = sony_demod_atsc3_CheckALPLock(p_demod, &lock, p_sync_state,p_alp_lock_all); if(lock == SONY_DEMOD_LOCK_RESULT_LOCKED) tslock = 1; else{ tslock = 0; } *p_tslock_state = tslock; return (tslock); } /***************************************************************************** * Function : sony_cxd6801_tslock * Description : ATSC1.0 * Input : sony_demod_t * p_demod uint8_t *p_tslock_state * Output : None * Return : * Others : * Record * 1.Date : 20230612 * Author : Shu.Wang * Modification: Created function *****************************************************************************/ int sony_cxd6801_tslock(sony_demod_t * p_demod, uint8_t *p_tslock_state) { sony_result_t result = 0; uint8_t vqLockState = 0; uint8_t agcLockState = 0; uint8_t tsLockState = 0; uint8_t unlockDetected = 0; result = sony_demod_atsc_monitor_SyncStat (p_demod, &vqLockState, &agcLockState, &tsLockState, &unlockDetected); *p_tslock_state = tsLockState; return result; } int sony_cxd6801_tuner_rssi(sony_integ_t * pInteg, int32_t* p_rflevel) { int32_t rfLevel = 0; sony_result_t result = 0; result = sony_integ_atsc_monitor_RFLevel (pInteg, &rfLevel); if (result != SONY_RESULT_OK) { rfLevel = -999999; } *p_rflevel = (rfLevel/1000); // dBm return result; } int sony_cxd6801_tuner_rssi_atsc3p0(sony_integ_t * pInteg, int32_t* p_rflevel) { sony_result_t result = 0; int32_t rfLevel = 0; result = sony_integ_atsc3_monitor_RFLevel (pInteg, &rfLevel); if (result != SONY_RESULT_OK) { rfLevel = -999999; } *p_rflevel = (rfLevel/1000); // dBm return result; } int sony_cxd6801_snr(sony_demod_t * p_demod, int32_t *p_snr) { int32_t snr; sony_result_t result = 0; result = sony_demod_atsc_monitor_SNR(p_demod, &snr); if (result != SONY_RESULT_OK) { *p_snr = 0; } *p_snr = snr/1000; return result; } int sony_cxd6801_snr_atsc3p0(sony_demod_t * p_demod, int32_t *p_snr) { int32_t snr = 0; sony_result_t result = 0; result = sony_demod_atsc3_monitor_SNR (p_demod, &snr); if (result == SONY_RESULT_OK) { //printf (" SNR | SNR | %d x 10^-3 dB\n", snr); } else { //printf (" SNR | Error | %s\n", Common_Result[result]); } snr = snr/1000; *p_snr = snr; return (snr); } int sony_cxd6801gl_status_update(sony_driver_instance_t *p_driver) { S_TUNER_INFO tuner_info; sony_cxd6801_tuner_rssi(&p_driver->integ, &tuner_info.rssi_db_tuner); sony_cxd6801_snr(&p_driver->demod, &tuner_info.snr); sony_cxd6801_tslock(&p_driver->demod, (uint8_t*)&tuner_info.locked); return 0; } #if 1 S_TUN_INFO g_tun_info={0}; S_TUN_INFO g_tun_info_bkp={0}; int usr_pr_l1b_info(sony_atsc3_l1basic_t *pl1b_info) { const char *time_str[] = {"none", "ms", "us", "ns"}; const char *miso_str[] = {"No MISO", "MISO with 64", "MISO with 256", "Reserved"}; const char *mode_str[] = {"Mode 1", "Mode 2", "Mode 3", "Mode 4", "Mode 5", "Mode 6", "Mode 7"}; const char *papr_str[] = {"NONE", "TR", "ACE", "TR_ACE"}; const char *fft_str[] = {"8k", "16k", "32k"}; const char *gi_str[] = {"Reserved", "1/192", "2/384", "3/512", "4/768", "5/1024", "6/1536", "7/2048", "8/2432", "9/3072", "10/3648", "11/4096", "12/4864"}; const char *sp_str[] = {"SP3_2", "SP3_4", "SP4_2", "SP4_4", "SP6_2", "SP6_4", "SP8_2", "SP8_4", "SP12_2", "SP12_4", "SP16_2", "SP16_4", "SP24_2", "SP24_4", "SP32_2", "SP32_4"}; if(!pl1b_info) return -1; printf ("-------------------------|-----------------|----------------- \n"); printf (" L1-Basic | L1B version | %u\n", pl1b_info->version); printf (" | MIMO SP enc | %u\n", pl1b_info->mimo_sp_enc); printf (" | LLS | %u\n", pl1b_info->lls_flg); printf (" | Timing info | %s\n", time_str[pl1b_info->time_info_flg]); printf (" | DRC | %u\n", pl1b_info->return_ch_flg); printf (" | PAPR | %s\n", papr_str[pl1b_info->papr]); printf (" | Frame Len mode | %u\n", pl1b_info->frame_length_mode); if (pl1b_info->frame_length_mode == 0) { printf (" | Frame Length | %u\n", pl1b_info->frame_length); printf (" | EXCESS SMP/SYM | %u\n", pl1b_info->excess_smp_per_sym); } else { printf (" | Time offset | %u\n", pl1b_info->time_offset); printf (" | Additional SMP | %u\n", pl1b_info->additional_smp); } printf (" | Subframe | %u\n", pl1b_info->num_subframe); printf (" | PB Symbol | %u\n", pl1b_info->pb_num_symbol); printf (" | PB Cred_coeff | %u\n", pl1b_info->pb_reduced_carriers); printf (" | L1D Content Tag | %u\n", pl1b_info->l1d_content_tag); printf (" | L1D Size | %u\n", pl1b_info->l1d_size); printf (" | L1D FEC type | %s\n", mode_str[pl1b_info->l1d_fec_type]); printf (" | L1D ADD Parity | %u\n", pl1b_info->l1d_add_parity_mode); printf (" | SF0 MIMO | %u\n", pl1b_info->sf0_mimo); printf (" | SF0 MISO | %s\n", miso_str[pl1b_info->sf0_miso]); printf (" | SF0 FFT size | %s\n", fft_str[pl1b_info->sf0_fft_size]); printf (" | SF0 Cred_coeff | %u\n", pl1b_info->sf0_reduced_carriers); printf (" | SF0 GI | %s\n", gi_str[pl1b_info->sf0_gi]); printf (" | SF0 OFDM Symbol | %u\n", pl1b_info->sf0_num_ofdm_symbol); printf (" | SF0 SP | %s\n", sp_str[pl1b_info->sf0_sp]); printf (" | SF0 SP boost | %u\n", pl1b_info->sf0_sp_boost); printf (" | SF0 sbs first | %u\n", pl1b_info->sf0_sbs_first); printf (" | SF0 sbs last | %u\n", pl1b_info->sf0_sbs_last); printf ("-------------------------|-----------------|----------------- \n"); return 0; } int usr_pr_bootstrap_info(sony_atsc3_bootstrap_t *pbootsrap) { const char *bw_str[] = {"6MHz", "7MHz", "8MHz"}; printf (" Bootstrap | BW diff | %u\n", pbootsrap->bw_diff); printf (" | BW | %s\n", bw_str[pbootsrap->system_bw]); printf (" | EA wakeup | %u\n", pbootsrap->ea_wake_up); printf ("-------------------------|-----------------|----------------- \n"); } int usr_pr_l1d_info(S_USR_L1D_INFO *pl1d_info, uint8 sub_idx) { int i,j; sony_atsc3_l1detail_common_t *pl1DCommon =&pl1d_info->l1DCommon; sony_atsc3_l1detail_subframe_t *pl1DSubframe=&pl1d_info->l1DSubframe[sub_idx]; sony_atsc3_l1detail_plp_t *pl1DPlp =&pl1d_info->l1DPlp[sub_idx][0]; printf (" L1-Detail Comm | L1D version | %u\n", pl1DCommon->version); printf (" | Num RF | %u\n", pl1DCommon->num_rf); printf (" | BSID | %u\n", pl1DCommon->bonded_bsid); printf (" | Time Sec | %u\n", pl1DCommon->time_sec); printf (" | Time mSec | %u\n", pl1DCommon->time_msec); printf (" | Time uSec | %u\n", pl1DCommon->time_usec); printf (" | Frame Len mode | %u\n", pl1DCommon->time_nsec); printf (" | BSID (Cur CH) | %u\n", pl1DCommon->bsid); printf (" | Res bit len | %u\n", pl1DCommon->reserved_bitlen); printf (" | | \n"); printf (" L1-Detail Subframe %d | Index | %u\n",sub_idx, pl1DSubframe->index); printf (" | MIMO | %u\n", pl1DSubframe->mimo); printf (" | MISO | %u\n", pl1DSubframe->miso); printf (" | FFT Size | %u\n", pl1DSubframe->fft_size); printf (" | Reduced Carriers| %u\n", pl1DSubframe->reduced_carriers); printf (" | Guard Interval | %u\n", pl1DSubframe->gi); printf (" | NUM OFDM SYMBOL | %u\n", pl1DSubframe->num_ofdm_symbol); printf (" | SP | %u\n", pl1DSubframe->sp); printf (" | SP BOOST | %u\n", pl1DSubframe->sp_boost); printf (" | SBS first flg | %u\n", pl1DSubframe->sbs_first); printf (" | SBS last flg | %u\n", pl1DSubframe->sbs_last); printf (" | Subframe Mux | %u\n", pl1DSubframe->subframe_mux); printf (" | Freq interleaver| %u\n", pl1DSubframe->freq_interleaver); printf (" | SBS null cells | %u\n", pl1DSubframe->sbs_null_cells); printf (" | Num PLP | %u\n", pl1DSubframe->num_plp); printf (" | | \n"); for(i=0;inum_plp+1;i++) { pl1DPlp =&pl1d_info->l1DPlp[sub_idx][i]; printf ("-------------------------------------------------\n"); printf (" L1-Detail PLP-%d | ID | %u\n",i, pl1DPlp->id); printf (" | LLS Flg | %u\n", pl1DPlp->lls_flg); printf (" | Layer | %u\n", pl1DPlp->layer); printf (" | Start | %u\n", pl1DPlp->start); printf (" | Size | %u\n", pl1DPlp->size); printf (" | Scramble Type | %u\n", pl1DPlp->scrambler_type); printf (" | FEC TYPE | %u\n", pl1DPlp->fec_type); printf (" | Modulation | %u\n", pl1DPlp->mod); printf (" | Code Rate | %u\n", pl1DPlp->cod); printf (" | Time Intlea Mode| %u\n", pl1DPlp->ti_mode); printf (" | FEC block Start | %u\n", pl1DPlp->fec_block_start); printf (" | CTI fec start | %u\n", pl1DPlp->cti_fec_block_start); printf (" | Num Ch Bonded | %u\n", pl1DPlp->num_ch_bonded); printf (" | ch bond format | %u\n", pl1DPlp->ch_bonding_format); printf (" | bonded rf id 0 | %u\n", pl1DPlp->bonded_rf_id_0); printf (" | bonded rf id 1 | %u\n", pl1DPlp->bonded_rf_id_1); printf (" | mimo stream comb| %u\n", pl1DPlp->mimo_stream_combine); printf (" | mimo iq intleav | %u\n", pl1DPlp->mimo_iq_interleave); printf (" | mimo ph | %u\n", pl1DPlp->mimo_ph); printf (" | plp type | %u\n", pl1DPlp->plp_type); printf (" | num subslice | %u\n", pl1DPlp->num_subslice); printf (" | subslice interval| %u\n", pl1DPlp->subslice_interval); printf (" | ext interleave | %u\n", pl1DPlp->ti_ext_interleave); printf (" | cti depth | %u\n", pl1DPlp->cti_depth); printf (" | cti start row | %u\n", pl1DPlp->cti_start_row); printf (" | hti inter subframe | %u\n", pl1DPlp->hti_inter_subframe); printf (" | hti num ti blocks | %u\n", pl1DPlp->hti_num_ti_blocks); printf (" | hti num fec blk max| %u\n", pl1DPlp->hti_num_fec_block_max); for(j=0;jhti_num_fec_block_max;j++){ printf (" | hti num fec blk %d | %u\n", i,pl1DPlp->hti_num_fec_block[i]); } printf (" | hti cell interleav | %u\n", pl1DPlp->hti_cell_interleave); printf (" | ldm inj leavel | %u\n", pl1DPlp->ldm_inj_level); } printf ("-------------------------|--------------------|----------------- \n"); } void usr_record_l1b_info_change_state(sony_atsc3_l1basic_t *p1, sony_atsc3_l1basic_t *p2) { printf("\n----l1b base info-----\r\n"); CMP_VALUE(p1->version, p2->version, "version"); CMP_VALUE(p1->mimo_sp_enc, p2->mimo_sp_enc, "mimo_sp_enc"); CMP_VALUE(p1->lls_flg, p2->lls_flg, "lls_flg"); CMP_VALUE(p1->time_info_flg, p2->time_info_flg, "time_info_flg"); CMP_VALUE(p1->return_ch_flg, p2->return_ch_flg, "return_ch_flg"); CMP_VALUE(p1->papr, p2->papr, "papr"); CMP_VALUE(p1->frame_length_mode, p2->frame_length_mode, "frame_length_mode"); CMP_VALUE(p1->excess_smp_per_sym, p2->excess_smp_per_sym, "excess_smp_per_sym"); CMP_VALUE(p1->time_offset, p2->time_offset, "time_offset"); CMP_VALUE(p1->additional_smp, p2->additional_smp, "additional_smp"); CMP_VALUE(p1->num_subframe, p2->num_subframe, "num_subframe"); CMP_VALUE(p1->pb_num_symbol, p2->pb_num_symbol, "pb_num_symbol"); CMP_VALUE(p1->pb_reduced_carriers, p2->pb_reduced_carriers, "pb_reduced_carriers"); CMP_VALUE(p1->l1d_content_tag, p2->l1d_content_tag, "l1d_content_tag"); CMP_VALUE(p1->l1d_size, p2->l1d_size, "l1d_size"); CMP_VALUE(p1->l1d_fec_type, p2->l1d_fec_type, "l1d_fec_type"); CMP_VALUE(p1->l1d_add_parity_mode, p2->l1d_add_parity_mode, "l1d_add_parity_mode"); CMP_VALUE(p1->sf0_mimo, p2->sf0_mimo, "sf0_mimo"); CMP_VALUE(p1->sf0_miso, p2->sf0_miso, "sf0_miso"); CMP_VALUE(p1->sf0_fft_size, p2->sf0_fft_size, "sf0_fft_size"); CMP_VALUE(p1->sf0_reduced_carriers, p2->sf0_reduced_carriers, "sf0_reduced_carriers"); CMP_VALUE(p1->sf0_gi, p2->sf0_gi, "sf0_gi"); CMP_VALUE(p1->sf0_num_ofdm_symbol, p2->sf0_num_ofdm_symbol, "sf0_num_ofdm_symbol"); CMP_VALUE(p1->sf0_sp, p2->sf0_sp, "sf0_sp"); CMP_VALUE(p1->sf0_sp_boost, p2->sf0_sp_boost, "sf0_sp_boost"); CMP_VALUE(p1->sf0_sbs_first, p2->sf0_sbs_first, "sf0_sbs_first"); CMP_VALUE(p1->sf0_sbs_last, p2->sf0_sbs_last, "sf0_sbs_last"); } void usr_record_l1d_com_info_change_state(sony_atsc3_l1detail_common_t *p1, sony_atsc3_l1detail_common_t *p2) { printf("\n----l1d com info-----\r\n"); CMP_VALUE(p1->version, p2->version, "version"); CMP_VALUE(p1->num_rf, p2->num_rf, "num_rf"); CMP_VALUE(p1->bonded_bsid, p2->bonded_bsid, "bonded_bsid"); CMP_VALUE(p1->time_sec, p2->time_sec, "time_sec"); CMP_VALUE(p1->time_msec, p2->time_msec, "time_msec"); CMP_VALUE(p1->time_usec, p2->time_usec, "time_usec"); CMP_VALUE(p1->time_nsec, p2->time_nsec, "time_nsec"); CMP_VALUE(p1->bsid, p2->bsid, "bsid"); CMP_VALUE(p1->reserved_bitlen, p2->reserved_bitlen, "reserved_bitlen"); } void usr_record_l1d_sub_info_change_state(sony_atsc3_l1detail_subframe_t *p1, sony_atsc3_l1detail_subframe_t *p2) { printf("\n----l1d subframe info-----\r\n"); CMP_VALUE(p1->index, p2->index, "index"); CMP_VALUE(p1->mimo, p2->mimo, "mimo"); CMP_VALUE(p1->miso, p2->miso, "miso"); CMP_VALUE(p1->fft_size, p2->fft_size, "fft_size"); CMP_VALUE(p1->reduced_carriers, p2->reduced_carriers, "reduced_carriers"); CMP_VALUE(p1->gi, p2->gi, "gi"); CMP_VALUE(p1->num_ofdm_symbol, p2->num_ofdm_symbol, "num_ofdm_symbol"); CMP_VALUE(p1->sp, p2->sp, "sp"); CMP_VALUE(p1->sp_boost, p2->sp_boost, "sp_boost"); CMP_VALUE(p1->sbs_first, p2->sbs_first, "sbs_first"); CMP_VALUE(p1->sbs_last, p2->sbs_last, "sbs_last"); CMP_VALUE(p1->subframe_mux, p2->subframe_mux, "subframe_mux"); CMP_VALUE(p1->freq_interleaver, p2->freq_interleaver, "freq_interleaver"); CMP_VALUE(p1->sbs_null_cells, p2->sbs_null_cells, "sbs_null_cells"); CMP_VALUE(p1->num_plp, p2->num_plp, "num_plp"); } void usr_record_l1d_plp_info_change_state(sony_atsc3_l1detail_plp_t *p1, sony_atsc3_l1detail_plp_t *p2) { printf("\n----l1d plp info-----\r\n"); CMP_VALUE(p1->id, p2->id, "id"); CMP_VALUE(p1->lls_flg, p2->lls_flg, "lls_flg"); CMP_VALUE(p1->layer, p2->layer, "layer"); CMP_VALUE(p1->start, p2->start, "start"); CMP_VALUE(p1->size, p2->size, "size"); CMP_VALUE(p1->scrambler_type, p2->scrambler_type, "scrambler_type"); CMP_VALUE(p1->fec_type, p2->fec_type, "fec_type"); CMP_VALUE(p1->mod, p2->mod, "mod"); CMP_VALUE(p1->cod, p2->cod, "cod"); CMP_VALUE(p1->ti_mode, p2->ti_mode, "ti_mode"); CMP_VALUE(p1->fec_block_start, p2->fec_block_start, "fec_block_start"); CMP_VALUE(p1->cti_fec_block_start, p2->cti_fec_block_start, "cti_fec_block_start"); CMP_VALUE(p1->num_ch_bonded, p2->num_ch_bonded, "num_ch_bonded"); CMP_VALUE(p1->ch_bonding_format, p2->ch_bonding_format, "ch_bonding_format"); CMP_VALUE(p1->bonded_rf_id_0, p2->bonded_rf_id_0, "bonded_rf_id_0"); CMP_VALUE(p1->bonded_rf_id_1, p2->bonded_rf_id_1, "bonded_rf_id_1"); CMP_VALUE(p1->mimo_stream_combine, p2->mimo_stream_combine, "mimo_stream_combine"); CMP_VALUE(p1->mimo_iq_interleave, p2->mimo_iq_interleave, "mimo_iq_interleave"); CMP_VALUE(p1->mimo_ph, p2->mimo_ph, "mimo_ph"); CMP_VALUE(p1->plp_type, p2->plp_type, "plp_type"); CMP_VALUE(p1->num_subslice, p2->num_subslice, "num_subslice"); CMP_VALUE(p1->subslice_interval, p2->subslice_interval, "subslice_interval"); CMP_VALUE(p1->ti_ext_interleave, p2->ti_ext_interleave, "ti_ext_interleave"); CMP_VALUE(p1->cti_depth, p2->cti_depth, "cti_depth"); CMP_VALUE(p1->cti_start_row, p2->cti_start_row, "cti_start_row"); CMP_VALUE(p1->hti_inter_subframe, p2->hti_inter_subframe, "hti_inter_subframe"); CMP_VALUE(p1->hti_num_ti_blocks, p2->hti_num_ti_blocks, "hti_num_ti_blocks"); CMP_VALUE(p1->hti_num_ti_blocks, p2->hti_num_ti_blocks, "hti_num_ti_blocks"); CMP_VALUE(p1->hti_num_fec_block_max, p2->hti_num_fec_block_max, "hti_num_fec_block_max"); CMP_VALUE(p1->hti_cell_interleave, p2->hti_cell_interleave, "hti_cell_interleave"); CMP_VALUE(p1->ldm_inj_level, p2->ldm_inj_level, "ldm_inj_level"); CMP_VALUE(p1->hti_num_fec_block[0], p2->hti_num_fec_block[0], "hti_num_fec_block[0]"); CMP_VALUE(p1->hti_num_fec_block[1], p2->hti_num_fec_block[1], "hti_num_fec_block[1]"); CMP_VALUE(p1->hti_num_fec_block[2], p2->hti_num_fec_block[2], "hti_num_fec_block[2]"); CMP_VALUE(p1->hti_num_fec_block[3], p2->hti_num_fec_block[3], "hti_num_fec_block[3]"); CMP_VALUE(p1->hti_num_fec_block[4], p2->hti_num_fec_block[4], "hti_num_fec_block[4]"); CMP_VALUE(p1->hti_num_fec_block[5], p2->hti_num_fec_block[5], "hti_num_fec_block[5]"); CMP_VALUE(p1->hti_num_fec_block[6], p2->hti_num_fec_block[6], "hti_num_fec_block[6]"); CMP_VALUE(p1->hti_num_fec_block[7], p2->hti_num_fec_block[7], "hti_num_fec_block[7]"); CMP_VALUE(p1->hti_num_fec_block[8], p2->hti_num_fec_block[8], "hti_num_fec_block[8]"); CMP_VALUE(p1->hti_num_fec_block[9], p2->hti_num_fec_block[9], "hti_num_fec_block[9]"); CMP_VALUE(p1->hti_num_fec_block[10], p2->hti_num_fec_block[10], "hti_num_fec_block[10]"); CMP_VALUE(p1->hti_num_fec_block[11], p2->hti_num_fec_block[11], "hti_num_fec_block[11]"); CMP_VALUE(p1->hti_num_fec_block[12], p2->hti_num_fec_block[12], "hti_num_fec_block[12]"); CMP_VALUE(p1->hti_num_fec_block[13], p2->hti_num_fec_block[13], "hti_num_fec_block[13]"); CMP_VALUE(p1->hti_num_fec_block[14], p2->hti_num_fec_block[14], "hti_num_fec_block[14]"); CMP_VALUE(p1->hti_num_fec_block[15], p2->hti_num_fec_block[15], "hti_num_fec_block[15]"); } int cmp_L1B_signaling_chg(sony_atsc3_l1basic_t *p_new_L1B, sony_atsc3_l1basic_t *p_old_L1B) { if(p_new_L1B->mimo_sp_enc != p_old_L1B->mimo_sp_enc){ printf("chg L1B_mimo_scattered_pilot_encoding\n"); return 1; } if(p_new_L1B->frame_length_mode != p_old_L1B->frame_length_mode){ printf("chg L1B_frame_length_mode\n"); return 1; } if(p_new_L1B->frame_length != p_old_L1B->frame_length){ printf("chg L1B_frame_length\n"); return 1; } if(p_new_L1B->num_subframe != p_old_L1B->num_subframe){ printf("chg L1B_num_subframes\n"); return 1; } if(p_new_L1B->pb_num_symbol != p_old_L1B->pb_num_symbol){ printf("chg L1B_preamble_num_symbols\n"); return 1; } if(p_new_L1B->pb_reduced_carriers != p_old_L1B->pb_reduced_carriers){ printf("chg L1B_preamble_reduced_carriers\n"); return 1; } if(p_new_L1B->l1d_fec_type != p_old_L1B->l1d_fec_type){ printf("chg L1B_L1_Detail_fec_type\n"); return 1; } if(p_new_L1B->sf0_mimo != p_old_L1B->sf0_mimo){ printf("chg L1B_first_sub_mimo\n"); return 1; } if(p_new_L1B->sf0_miso != p_old_L1B->sf0_miso){ printf("chg L1B_first_sub_miso\n"); return 1; } if(p_new_L1B->sf0_fft_size != p_old_L1B->sf0_fft_size){ printf("chg L1B_first_sub_fft_size\n"); return 1; } if(p_new_L1B->sf0_reduced_carriers != p_old_L1B->sf0_reduced_carriers){ printf("chg L1B_first_sub_reduced_carriers\n"); return 1; } if(p_new_L1B->sf0_gi != p_old_L1B->sf0_gi){ printf("chg L1B_first_sub_guard_interval\n"); return 1; } if(p_new_L1B->sf0_num_ofdm_symbol != p_old_L1B->sf0_num_ofdm_symbol){ printf("chg L1B_first_sub_num_ofdm_symbols\n"); return 1; } if(p_new_L1B->sf0_sp != p_old_L1B->sf0_sp){ printf("chg L1B_first_sub_scattered_pilot_pattern\n"); return 1; } if(p_new_L1B->sf0_sp_boost != p_old_L1B->sf0_sp_boost){ printf("chg L1B_first_sub_scattered_pilot_boost\n"); return 1; } if(p_new_L1B->sf0_sbs_first != p_old_L1B->sf0_sbs_first){ printf("chg L1B_first_sub_sbs_first\n"); return 1; } if(p_new_L1B->sf0_sbs_last != p_old_L1B->sf0_sbs_last){ printf("chg L1B_first_sub_sbs_last\n"); return 1; } return 0; } int cmp_L1D_signaling_chg(S_USR_L1D_INFO *p_new_L1D, S_USR_L1D_INFO *p_old_L1D, uint8_t sub_num) { int i, j; for(i=0; il1DSubframe[i].freq_interleaver != p_old_L1D->l1DSubframe[i].freq_interleaver){ printf("chg L1D_frequency_interleaver\n"); return 1; } if(p_new_L1D->l1DSubframe[i].sbs_null_cells != p_old_L1D->l1DSubframe[i].sbs_null_cells){ printf("chg L1D_sbs_null_cells\n"); return 1; } if(p_new_L1D->l1DSubframe[i].num_plp != p_old_L1D->l1DSubframe[i].num_plp){ printf("chg L1D_num_plp\n"); return 1; } for(j=0;j<4;j++){ if(p_new_L1D->l1DPlp[i][j].mod != p_old_L1D->l1DPlp[i][j].mod){ printf("chg L1D_plp_mod\n"); return 1; } if(p_new_L1D->l1DPlp[i][j].cod != p_old_L1D->l1DPlp[i][j].cod){ printf("chg L1D_plp_cod\n"); return 1; } if(p_new_L1D->l1DPlp[i][j].fec_type != p_old_L1D->l1DPlp[i][j].fec_type){ printf("chg L1D_plp_fec_type\n"); return 1; } if(p_new_L1D->l1DPlp[i][j].ti_mode != p_old_L1D->l1DPlp[i][j].ti_mode){ printf("chg L1D_plp_ti_mode\n"); return 1; } } } return 0; } int check_tun_info_chg(S_TUN_INFO *pbkp, S_TUN_INFO *pcur) { int ret=0; int i; //g_tun_info if(cmp_L1B_signaling_chg(&g_tun_info.l1b, &g_tun_info.l1b)){ ret=1; } if(cmp_L1D_signaling_chg(&g_tun_info.l1d, &g_tun_info.l1d, g_tun_info.l1b.num_subframe)){ ret=1; } return ret; } static int get_tun_plp_array_idx(int subframe_idx, int plp_idx) { int j; int plp_arr_idx = 0; plp_arr_idx = plp_idx; for(int j=0;jdemod, &syncState, &alpLockState[0], &alpLockAll, &alpUnlockDetected); if (result == SONY_RESULT_OK) { /*printf (" SyncStat | Sync Status | %u\n", syncState); for (j = 0; j < 4; j++) { uint8_t alpLock = alpLockState[j]; printf (" | ALP[%d] Lock | %s\n", j, lock_str[alpLock]); } printf (" | ALP Lock All | %s\n", lock_str[alpLockAll]); printf (" | ALP Unlock | %s\n", unlock_str[alpUnlockDetected])*/ } else { printf (" SyncStat | Error | %s\n", Common_Result[result]); } //printf ("-------------------------|-----------------|----------------- \n"); } if(alpLockAll==1) { sony_atsc3_l1detail_raw_t l1detail={0}; //bootstrap result = sony_demod_atsc3_monitor_Bootstrap (&p_driver->demod, &g_tun_info.boots); if (result == SONY_RESULT_OK) { // usr_pr_bootstrap_info(&g_tun_info.boots); } else { printf (" Bootstrap | Error | %s\n", Common_Result[result]); } //get preamble_pilot_dx sony_atsc3_ofdm_t ofdm; u8 preamble_pilot_dx; result = sony_demod_atsc3_monitor_OFDM (&p_driver->demod, &ofdm); g_tun_info.oth.preamble_pilot_dx = conv_sony_pilot_dx_array[ofdm.pb_pilot]; result = sony_demod_atsc3_monitor_L1Detail_raw(&p_driver->demod, &g_tun_info.l1b, &l1detail); if(result==SONY_RESULT_OK){ //l1b // usr_pr_l1b_info(&g_tun_info.l1b); plp_arr_idx = plpinfos.plplist[0].id; if(g_tun_info.l1b.num_subframe<2){ for(subfrmidx=0;subfrmidx0){ plp_arr_idx = get_tun_plp_array_idx(subfrmidx, 0); } sony_demod_atsc3_monitor_L1Detail_convert(&p_driver->demod, &g_tun_info.l1b, &l1detail, plp_arr_idx, &g_tun_info.l1d.l1DCommon, &g_tun_info.l1d.l1DSubframe[subfrmidx], &g_tun_info.l1d.l1DPlp[subfrmidx][0]); //printf(">subxi=%d plpnum=%d plpidxj=%d id=%d\n",subfrmidx,g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp+1, 0, plpinfos.plplist[plp_arr_idx].id); if(g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp>=1 && g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp<=3){ for(plpidx=1; plpidx<=g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp; plpidx++){ plp_arr_idx = get_tun_plp_array_idx(subfrmidx, plpidx); sony_demod_atsc3_monitor_L1Detail_convert(&p_driver->demod, &g_tun_info.l1b, &l1detail, plpinfos.plplist[plp_arr_idx].id, &g_tun_info.l1d.l1DCommon, &g_tun_info.l1d.l1DSubframe[subfrmidx], &g_tun_info.l1d.l1DPlp[subfrmidx][plpidx]); //printf(">subxi=%d plpnum=%d plpidxj=%d id=%d\n",subfrmidx,g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp+1, plpidx, plpinfos.plplist[plp_arr_idx].id); //printf(">subxi=%d plpnum=%d plpidxj=%d id=%02d lls_flg=%d bflg=%d\n",subfrmidx,g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp+1, // plpidx, plpinfos.plplist[plp_arr_idx].id, g_tun_info.l1d.l1DPlp[subfrmidx][plpidx].lls_flg, g_tun_info.l1b.lls_flg); } } if(g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp>3){ printf("num_plp over max_is_4, now=%d!\n",g_tun_info.l1d.l1DSubframe[subfrmidx].num_plp); } // usr_pr_l1d_info(&g_tun_info.l1d, subfrmidx); } } else{ printf("num_subframe over max_is_2, now=%d!\n",g_tun_info.l1b.num_subframe); } } else{ printf (" L1B-L1D | Error | %s\n", Common_Result[result]); } } } if(check_tun_info_chg(&g_tun_info_bkp, &g_tun_info)==1 || 0 /*PR04:SMOD no tun_ctl(atsc3 only)*/){ memcpy(&g_tun_info_bkp, &g_tun_info, sizeof(g_tun_info)); ret= 1; } //printf("<<<==========================================================\n\n\n"); return ret; } void usr_sony_cxd6801gl_state_monitor(sony_driver_instance_t *p_driver) { int i; int j; sony_result_t result = SONY_RESULT_OK; #define MONITOR_LOOP_COUNT 1 /*---------------------------------------------------------------------------------- * Monitor the Channel *------------------------------------------------------------------------------- */ printf("\n>>>\n"); printf ("------------------------------------------\n"); printf (" Monitor\n"); printf ("------------------------------------------\n"); static sony_atsc3_l1basic_t stc_l1basic={0}; static sony_atsc3_l1detail_common_t stc_l1DetailCommon={0}; static sony_atsc3_l1detail_subframe_t stc_l1DetailSubframe={0}; static sony_atsc3_l1detail_plp_t stc_l1DetailPlp={0}; static char l1d_first_flg=1; if(1){ #if 1 printf ("\n Monitor Iteration : %u \n\n",i); printf ("-------------------------|-----------------|----------------- \n"); printf (" MONITOR NAME | PARAMETER | VALUE \n"); printf ("-------------------------|-----------------|----------------- \n"); {//sony_demod_atsc3_monitor_SyncStat const char *lock_str[] = {"No", "Yes"}; const char *unlock_str[] = {"Not Detected", "Detected"}; uint8_t syncState = 0; uint8_t alpLockState[4] = {0}; uint8_t alpLockAll = 0; uint8_t alpUnlockDetected = 0; result = (sony_result_t)sony_demod_atsc3_monitor_SyncStat (&p_driver->demod, &syncState, &alpLockState[0], &alpLockAll, &alpUnlockDetected); if (result == SONY_RESULT_OK) { printf (" SyncStat | Sync Status | %u\n", syncState); for (j = 0; j < 4; j++) { uint8_t alpLock = alpLockState[j]; printf (" | ALP[%d] Lock | %s\n", j, lock_str[alpLock]); } printf (" | ALP Lock All | %s\n", lock_str[alpLockAll]); printf (" | ALP Unlock | %s\n", unlock_str[alpUnlockDetected]); } else { printf (" SyncStat | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_IFAGCOut uint32_t ifAGCOut = 0; result = sony_demod_atsc3_monitor_IFAGCOut (&p_driver->demod, &ifAGCOut); if (result == SONY_RESULT_OK) { printf (" IFAGCOut | IF AGC | %u\n", ifAGCOut); } else { printf (" IFAGCOut | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_CarrierOffset int32_t offset; result = sony_demod_atsc3_monitor_CarrierOffset (&p_driver->demod, &offset); if (result == SONY_RESULT_OK) { printf (" CarrierOffset | Carrier Offset | %d Hz\n", offset); } else { printf (" CarrierOffset | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_SpectrumSense const char *spectrumsense_str[2] = {"Normal", "Inverted"}; sony_demod_terr_cable_spectrum_sense_t sense; result = sony_demod_atsc3_monitor_SpectrumSense (&p_driver->demod, &sense); if (result == SONY_RESULT_OK) { printf (" SpectrumSense | Spectrum Sense | %s\n", spectrumsense_str[sense]); } else { printf (" SpectrumSense | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_SamplingOffset int32_t ppmOffset; result = sony_demod_atsc3_monitor_SamplingOffset (&p_driver->demod, &ppmOffset); if (result == SONY_RESULT_OK) { printf (" SamplingOffset | PPM Offset | %d x 10^-2 ppm\n", ppmOffset); } else { printf (" SamplingOffset | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_SNR int32_t snr; result = sony_demod_atsc3_monitor_SNR (&p_driver->demod, &snr); if (result == SONY_RESULT_OK) { printf (" SNR | SNR | %d x 10^-3 dB\n", snr); } else { printf (" SNR | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_PreLDPCBER uint32_t ber[4]; result = sony_demod_atsc3_monitor_PreLDPCBER (&p_driver->demod, &ber[0]); if (result == SONY_RESULT_OK) { printf (" PreLDPCBER | Pre-LDPC BER[0] | %u x 10^-7\n", ber[0]); for(j = 1; j < 4; j++) { if (ber[j] == SONY_DEMOD_ATSC3_MONITOR_PRELDPCBER_INVALID) { printf (" | Pre-LDPC BER[%d] | Unused\n", j); } else { printf (" | Pre-LDPC BER[%d] | %u x 10^-7\n", j, ber[j]); } } } else { printf (" PreLDPCBER | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_PreBCHBER uint32_t ber[4]; result = sony_demod_atsc3_monitor_PreBCHBER (&p_driver->demod, &ber[0]); if (result == SONY_RESULT_OK) { printf (" PreBCHBER | Pre-BCH BER[0] | %u x 10^-9\n", ber[0]); for(j = 1; j < 4; j++) { if (ber[j] == SONY_DEMOD_ATSC3_MONITOR_PRELDPCBER_INVALID) { printf (" | Pre-BCH BER[%d] | Unused\n", j); } else { printf (" | Pre-BCH BER[%d] | %u x 10^-9\n", j, ber[j]); } } } else { printf (" PreBCHBER | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_PostBCHFER uint32_t fer[4]; result = sony_demod_atsc3_monitor_PostBCHFER (&p_driver->demod, &fer[0]); if (result == SONY_RESULT_OK) { printf (" PostBCHFER | Post-BCH FER[0] | %u x 10^-6\n", fer[0]); for(j = 1; j < 4; j++) { if (fer[j] == SONY_DEMOD_ATSC3_MONITOR_POSTBCHFER_INVALID) { printf (" | Post-BCH FER[%d] | Unused\n", j); } else { printf (" | Post-BCH FER[%d] | %u x 10^-6\n", j, fer[j]); } } } else { printf (" PostBCHFER | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_BBPacketErrorNumber uint32_t pen[4]; result = sony_demod_atsc3_monitor_BBPacketErrorNumber (&p_driver->demod, &pen[0]); if (result == SONY_RESULT_OK) { printf (" BBPacketErrorNumber | BBPacketError[0]| %u\n", pen[0]); for(j = 1; j < 4; j++) { printf (" | BBPacketError[%d]| %u\n", j, pen[j]); } } else { printf (" BBPacketErrorNumber | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_Bootstrap const char *bw_str[] = {"6MHz", "7MHz", "8MHz"}; sony_atsc3_bootstrap_t boot_strap; result = sony_demod_atsc3_monitor_Bootstrap (&p_driver->demod, &boot_strap); if (result == SONY_RESULT_OK) { printf (" Bootstrap | BW diff | %u\n", boot_strap.bw_diff); printf (" | BW | %s\n", bw_str[boot_strap.system_bw]); printf (" | EA wakeup | %u\n", boot_strap.ea_wake_up); } else { printf (" OFDM | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_OFDM const char *bw_str[] = {"6MHz", "7MHz", "8MHz"}; const char *mode_str[] = {"Mode 1", "Mode 2", "Mode 3", "Mode 4", "Mode 5", "Mode 6", "Mode 7"}; const char *papr_str[] = {"NONE", "TR", "ACE", "TR_ACE"}; const char *fft_str[] = {"8k", "16k", "32k"}; const char *gi_str[] = {"Reserved", "1/192", "2/384", "3/512", "4/768", "5/1024", "6/1536", "7/2048", "8/2432", "9/3072", "10/3648", "11/4096", "12/4864"}; const char *sp_str[] = {"SP3_2", "SP3_4", "SP4_2", "SP4_4", "SP6_2", "SP6_4", "SP8_2", "SP8_4", "SP12_2", "SP12_4", "SP16_2", "SP16_4", "SP24_2", "SP24_4", "SP32_2", "SP32_4"}; const char *pilot_str[] = {"Dx3", "Dx4", "Dx6", "Dx8", "Dx12", "Dx16", "Dx24", "Dx32"}; sony_atsc3_ofdm_t ofdm; result = sony_demod_atsc3_monitor_OFDM (&p_driver->demod, &ofdm); if (result == SONY_RESULT_OK) { printf (" OFDM | BW | %s\n", bw_str[ofdm.system_bw]); printf (" | BS Symbol | %u\n", ofdm.bs_num_symbol); printf (" | Subframe | %u\n", ofdm.num_subframe); printf (" | L1B FEC type | %s\n", mode_str[ofdm.l1b_fec_type]); printf (" | PAPR | %s\n", papr_str[ofdm.papr]); printf (" | PB Symbol | %u\n", ofdm.pb_num_symbol); printf (" | PB FFT size | %s\n", fft_str[ofdm.pb_fft_size]); printf (" | PB Pilot | %s\n", pilot_str[ofdm.pb_pilot]); printf (" | PB Cred_coeff | %u\n", ofdm.pb_reduced_carriers); printf (" | PB GI | %s\n", gi_str[ofdm.pb_gi]); printf (" | SF0 FFT size | %s\n", fft_str[ofdm.sf0_fft_size]); printf (" | SF0 SP | %s\n", sp_str[ofdm.sf0_sp]); printf (" | SF0 Cred_coeff | %u\n", ofdm.sf0_reduced_carriers); printf (" | SF0 GI | %s\n", gi_str[ofdm.sf0_gi]); printf (" | SF0 SP boost | %u\n", ofdm.sf0_sp_boost); printf (" | SF0 sbs first | %u\n", ofdm.sf0_sbs_first); printf (" | SF0 sbs last | %u\n", ofdm.sf0_sbs_last); printf (" | SF0 OFDM Symbol | %u\n", ofdm.sf0_num_ofdm_symbol); } else { printf (" OFDM | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } #endif {//sony_demod_atsc3_monitor_L1Basic const char *time_str[] = {"none", "ms", "us", "ns"}; const char *miso_str[] = {"No MISO", "MISO with 64", "MISO with 256", "Reserved"}; const char *mode_str[] = {"Mode 1", "Mode 2", "Mode 3", "Mode 4", "Mode 5", "Mode 6", "Mode 7"}; const char *papr_str[] = {"NONE", "TR", "ACE", "TR_ACE"}; const char *fft_str[] = {"8k", "16k", "32k"}; const char *gi_str[] = {"Reserved", "1/192", "2/384", "3/512", "4/768", "5/1024", "6/1536", "7/2048", "8/2432", "9/3072", "10/3648", "11/4096", "12/4864"}; const char *sp_str[] = {"SP3_2", "SP3_4", "SP4_2", "SP4_4", "SP6_2", "SP6_4", "SP8_2", "SP8_4", "SP12_2", "SP12_4", "SP16_2", "SP16_4", "SP24_2", "SP24_4", "SP32_2", "SP32_4"}; sony_atsc3_l1basic_t l1basic; result = sony_demod_atsc3_monitor_L1Basic (&p_driver->demod, &l1basic); if (result == SONY_RESULT_OK) { #if USR_PR_TUNER_INFO printf (" L1-Basic | L1B version | %u\n", l1basic.version); printf (" | MIMO SP enc | %u\n", l1basic.mimo_sp_enc); printf (" | LLS | %u\n", l1basic.lls_flg); printf (" | Timing info | %s\n", time_str[l1basic.time_info_flg]); printf (" | DRC | %u\n", l1basic.return_ch_flg); printf (" | PAPR | %s\n", papr_str[l1basic.papr]); printf (" | Frame Len mode | %u\n", l1basic.frame_length_mode); if (l1basic.frame_length_mode == 0) { printf (" | Frame Length | %u\n", l1basic.frame_length); printf (" | EXCESS SMP/SYM | %u\n", l1basic.excess_smp_per_sym); } else { printf (" | Time offset | %u\n", l1basic.time_offset); printf (" | Additional SMP | %u\n", l1basic.additional_smp); } printf (" | Subframe | %u\n", l1basic.num_subframe); printf (" | PB Symbol | %u\n", l1basic.pb_num_symbol); printf (" | PB Cred_coeff | %u\n", l1basic.pb_reduced_carriers); printf (" | L1D Content Tag | %u\n", l1basic.l1d_content_tag); printf (" | L1D Size | %u\n", l1basic.l1d_size); printf (" | L1D FEC type | %s\n", mode_str[l1basic.l1d_fec_type]); printf (" | L1D ADD Parity | %u\n", l1basic.l1d_add_parity_mode); printf (" | SF0 MIMO | %u\n", l1basic.sf0_mimo); printf (" | SF0 MISO | %s\n", miso_str[l1basic.sf0_miso]); printf (" | SF0 FFT size | %s\n", fft_str[l1basic.sf0_fft_size]); printf (" | SF0 Cred_coeff | %u\n", l1basic.sf0_reduced_carriers); printf (" | SF0 GI | %s\n", gi_str[l1basic.sf0_gi]); printf (" | SF0 OFDM Symbol | %u\n", l1basic.sf0_num_ofdm_symbol); printf (" | SF0 SP | %s\n", sp_str[l1basic.sf0_sp]); printf (" | SF0 SP boost | %u\n", l1basic.sf0_sp_boost); printf (" | SF0 sbs first | %u\n", l1basic.sf0_sbs_first); printf (" | SF0 sbs last | %u\n", l1basic.sf0_sbs_last); #endif//USR_PR_TUNER_INFO } else { printf (" L1-Basic | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } {//sony_demod_atsc3_monitor_L1Detail_convert const char *time_str[] = {"none", "ms", "us", "ns"}; const char *miso_str[] = {"No MISO", "MISO with 64", "MISO with 256", "Reserved"}; const char *mode_str[] = {"Mode 1", "Mode 2", "Mode 3", "Mode 4", "Mode 5", "Mode 6", "Mode 7"}; const char *papr_str[] = {"NONE", "TR", "ACE", "TR_ACE"}; const char *fft_str[] = {"8k", "16k", "32k"}; const char *gi_str[] = {"Reserved", "1/192", "2/384", "3/512", "4/768", "5/1024", "6/1536", "7/2048", "8/2432", "9/3072", "10/3648", "11/4096", "12/4864"}; const char *sp_str[] = {"SP3_2", "SP3_4", "SP4_2", "SP4_4", "SP6_2", "SP6_4", "SP8_2", "SP8_4", "SP12_2", "SP12_4", "SP16_2", "SP16_4", "SP24_2", "SP24_4", "SP32_2", "SP32_4"}; sony_atsc3_l1basic_t l1basic; sony_atsc3_l1detail_raw_t l1detail; result = sony_demod_atsc3_monitor_L1Detail_raw(&p_driver->demod, &l1basic, &l1detail); uint8 usr_plp_id = 2; sony_atsc3_l1detail_common_t l1DetailCommon; sony_atsc3_l1detail_subframe_t l1DetailSubframe; sony_atsc3_l1detail_plp_t l1DetailPlp; sony_atsc3_bootstrap_t Bootstrap; sony_demod_atsc3_monitor_Bootstrap(&p_driver->demod,&Bootstrap); sony_demod_atsc3_monitor_L1Detail_convert(&p_driver->demod, &l1basic, &l1detail, usr_plp_id, &l1DetailCommon, &l1DetailSubframe, &l1DetailPlp); if (result == SONY_RESULT_OK) { #if USR_PR_TUNER_INFO printf (" L1-Detail Comm | L1D version | %u\n", l1DetailCommon.version); printf (" | Num RF | %u\n", l1DetailCommon.num_rf); printf (" | BSID | %u\n", l1DetailCommon.bonded_bsid); printf (" | Time Sec | %u\n", l1DetailCommon.time_sec); printf (" | Time mSec | %u\n", l1DetailCommon.time_msec); printf (" | Time uSec | %u\n", l1DetailCommon.time_usec); printf (" | Frame Len mode | %u\n", l1DetailCommon.time_nsec); printf (" | BSID (Cur CH) | %u\n", l1DetailCommon.bsid); printf (" | Res bit len | %u\n", l1DetailCommon.reserved_bitlen); printf (" | | \n"); printf (" L1-Detail Subframe | Index | %u\n", l1DetailSubframe.index); printf (" | MIMO | %u\n", l1DetailSubframe.mimo); printf (" | MISO | %u\n", l1DetailSubframe.miso); printf (" | FFT Size | %u\n", l1DetailSubframe.fft_size); printf (" | Reduced Carriers| %u\n", l1DetailSubframe.reduced_carriers); printf (" | Guard Interval | %u\n", l1DetailSubframe.gi); printf (" | NUM OFDM SYMBOL | %u\n", l1DetailSubframe.num_ofdm_symbol); printf (" | SP | %u\n", l1DetailSubframe.sp); printf (" | SP BOOST | %u\n", l1DetailSubframe.sp_boost); printf (" | SBS first flg | %u\n", l1DetailSubframe.sbs_first); printf (" | SBS last flg | %u\n", l1DetailSubframe.sbs_last); printf (" | Subframe Mux | %u\n", l1DetailSubframe.subframe_mux); printf (" | Freq interleaver| %u\n", l1DetailSubframe.freq_interleaver); printf (" | SBS null cells | %u\n", l1DetailSubframe.sbs_null_cells); printf (" | Num PLP | %u\n", l1DetailSubframe.num_plp); printf (" | | \n"); printf (" L1-Detail PLP | ID | %u\n", l1DetailPlp.id); printf (" | LLS Flg | %u\n", l1DetailPlp.lls_flg); printf (" | Layer | %u\n", l1DetailPlp.layer); printf (" | Start | %u\n", l1DetailPlp.start); printf (" | Size | %u\n", l1DetailPlp.size); printf (" | Scramble Type | %u\n", l1DetailPlp.scrambler_type); printf (" | FEC TYPE | %u\n", l1DetailPlp.fec_type); printf (" | Modulation | %u\n", l1DetailPlp.mod); printf (" | Code Rate | %u\n", l1DetailPlp.cod); printf (" | Time Intlea Mode| %u\n", l1DetailPlp.ti_mode); printf (" | FEC block Start | %u\n", l1DetailPlp.fec_block_start); printf (" | CTI fec start | %u\n", l1DetailPlp.cti_fec_block_start); printf (" | Num Ch Bonded | %u\n", l1DetailPlp.num_ch_bonded); printf (" | ch bond format | %u\n", l1DetailPlp.ch_bonding_format); printf (" | bonded rf id 0 | %u\n", l1DetailPlp.bonded_rf_id_0); printf (" | bonded rf id 1 | %u\n", l1DetailPlp.bonded_rf_id_1); printf (" | mimo stream comb| %u\n", l1DetailPlp.mimo_stream_combine); printf (" | mimo iq intleav | %u\n", l1DetailPlp.mimo_iq_interleave); printf (" | mimo ph | %u\n", l1DetailPlp.mimo_ph); printf (" | plp type | %u\n", l1DetailPlp.plp_type); printf (" | num subslice | %u\n", l1DetailPlp.num_subslice); printf (" | subslice interval| %u\n", l1DetailPlp.subslice_interval); printf (" | ext interleave | %u\n", l1DetailPlp.ti_ext_interleave); printf (" | cti depth | %u\n", l1DetailPlp.cti_depth); printf (" | cti start row | %u\n", l1DetailPlp.cti_start_row); printf (" | hti inter subframe | %u\n", l1DetailPlp.hti_inter_subframe); printf (" | hti num ti blocks | %u\n", l1DetailPlp.hti_num_ti_blocks); printf (" | hti num fec blk max| %u\n", l1DetailPlp.hti_num_fec_block_max); for(i=0;i<16;i++){ printf (" | hti num fec blk %d| %u\n", i,l1DetailPlp.hti_num_fec_block[i]); } printf (" | hti cell interleav | %u\n", l1DetailPlp.hti_cell_interleave); printf (" | ldm inj leavel | %u\n", l1DetailPlp.ldm_inj_level); #endif//USR_PR_TUNER_INFO } else { printf (" L1-Detail | Error | %s\n", Common_Result[result]); } printf ("-------------------------|-----------------|----------------- \n"); } printf("<<<\n\n\n"); //SONY_SLEEP (1000); } } void usr_sony_cxd6801gl_state_info(sony_driver_instance_t *p_driver) { usr_sony_cxd6801gl_state_monitor(p_driver); } #endif static void atsc3ScanCallbackHandler (sony_integ_t * pInteg, sony_integ_atsc3_scan_result_t * pResult, sony_integ_atsc3_scan_param_t * pScanParam) { sony_result_t result = SONY_RESULT_OK; /* * This function is provided as an example callback handler. * It simply displays the channel information to the console. * It also waits for TS lock as a scan callback is made after only * demodulator lock is acheived. Depending on the system requirements you could * use this function to monitor for detailed channel parameters (constellation, * coderate, carrier offset, TS rate etc.). */ if (pResult->tuneResult == SONY_RESULT_OK) { char * alpLock; int32_t carrierOffset = 0; int32_t snr = 0; int32_t rfLevel = 0; /* Callback contains channel information, so output channel information to table. */ result = sony_integ_atsc3_WaitALPLock (pInteg); alpLock = (result == SONY_RESULT_OK) ? "Yes" : " No"; printf ("alpLock %s\n",alpLock); /* Allow the monitors time to settle */ SONY_SLEEP (1000); /* Get carrier offset to compensate frequency. */ result = sony_demod_atsc3_monitor_CarrierOffset (pInteg->pDemod, &carrierOffset); if (result != SONY_RESULT_OK) { carrierOffset = 0; } /* Hz to kHz */ if (carrierOffset > 0) { carrierOffset += 500; } else { carrierOffset -= 500; } carrierOffset /= 1000; result = sony_demod_atsc3_monitor_SNR (pInteg->pDemod, &snr); if (result != SONY_RESULT_OK) { snr = 0; } result = sony_integ_atsc3_monitor_RFLevel (pInteg, &rfLevel); if (result != SONY_RESULT_OK) { rfLevel = -999999; } printf (" | %6u | %s | %2u.%03u | %4d.%03u |\n", pResult->tuneParam.centerFreqKHz + carrierOffset, /* Compensated frequency */ alpLock, snr / 1000, snr % 1000, -((-rfLevel) / 1000), (-rfLevel) % 1000); /* RF Level < 0 */ } else { } } // 综合信号检测函数 typedef enum { SIGNAL_STATUS_NO_SIGNAL = 0, SIGNAL_STATUS_WEAK_SIGNAL = 1, SIGNAL_STATUS_GOOD_SIGNAL = 2, SIGNAL_STATUS_ERROR = -1 } signal_status_t; signal_status_t usr_detect_signal_comprehensive(sony_demod_t *pDemod) { uint8_t vqlock, agclock, tslock, unlockDetected; uint32_t ifAgc; sony_result_t result; int retry = 0; printf("\n=== Comprehensive Signal Detection ===\n"); // 等待AGC稳定，最多等待300ms for (retry = 0; retry < 3; retry++) { usleep(100 * 1000); // 100ms // 1. 检查ISIGNAL_PRESENCE和AGC lock result = sony_demod_atsc_monitor_SyncStat(pDemod, &vqlock, &agclock, &tslock, &unlockDetected); if (result != SONY_RESULT_OK) { printf("Error reading sync stat\n"); return SIGNAL_STATUS_ERROR; } printf("Attempt %d: unlockDetected=%d, agclock=%d, vqlock=%d, tslock=%d\n", retry + 1, unlockDetected, agclock, vqlock, tslock); // 如果明确检测到无信号，立即返回 if (unlockDetected) { printf("Result: NO SIGNAL (ISIGNAL_PRESENCE=0)\n"); return SIGNAL_STATUS_NO_SIGNAL; } // 如果AGC已锁定，继续检查信号强度 if (agclock) { break; } } // 2. 读取IF AGC值评估信号强度 result = sony_demod_atsc_monitor_IFAGCOut(pDemod, &ifAgc); if (result == SONY_RESULT_OK) { printf("IF AGC: 0x%04X (%d)\n", ifAgc, ifAgc); if (ifAgc >= 0x3800) { printf("Result: NO SIGNAL or VERY WEAK (IF AGC too high)\n"); return SIGNAL_STATUS_NO_SIGNAL; } else if (ifAgc >= 0x2800) { printf("Result: WEAK SIGNAL (may not lock)\n"); return SIGNAL_STATUS_WEAK_SIGNAL; } else { printf("Result: GOOD SIGNAL\n"); return SIGNAL_STATUS_GOOD_SIGNAL; } } // 3. 如果无法读取IF AGC，根据AGC lock状态判断 if (agclock) { printf("Result: SIGNAL PRESENT (AGC locked)\n"); return SIGNAL_STATUS_GOOD_SIGNAL; } else { printf("Result: NO SIGNAL (AGC not locked after 300ms)\n"); return SIGNAL_STATUS_NO_SIGNAL; } } int sonytuner_init(u32 freqMHz, u8 atsc_ver) { uint8 tune_state = 0; int tslock = 0; int i =0; sony_result_t result; struct timeval tuner_tv_start; struct timeval tuner_tv_end; static u8 stc_init_flg = 0; static sony_atsc3_tune_param_t tuneParam3p0={0}; u8 tmp_actual_tun_plpnum = 0; printf("\n==tuner init ready==\n\n"); printf ("RX tuner: ATSC%d.0 freq: %d MHz.\n", atsc_ver,freqMHz); if(stc_init_flg==0){ result = sony_InitializeDriver(&atsc_driver, 0); } get_time(&tuner_tv_start); if(atsc_ver==1) { sony_atsc_tune_param_t tuneParam; tuneParam.centerFreqKHz = freqMHz *1000; /* Channel center frequency in KHz */ result = sony_integ_atsc_Tune(&atsc_driver.integ, &tuneParam); if(result != SONY_RESULT_OK) { printf("atsc tune failed\n"); } //usr_detect_signal_comprehensive(atsc_driver.integ.pDemod); while(1){ if(tune_state==0) { result = sony_cxd6801_tslock(&atsc_driver.demod, (u8*)&tslock); if(result != SONY_RESULT_OK){ printf("Error : sony_integ_atsc_Tune failed [result=%d]\n",result); tune_state=0; } else{ tune_state = 1; printf("State : atsc1.0 tune success!\n"); return 0; } } get_time(&tuner_tv_end); if(tuner_tv_end.tv_sec > (tuner_tv_start.tv_sec+TUNER_LOCK_CHECK_WAIT_SEC)) return -1; usleep(1000*1000); } } else if(atsc_ver == 3) { u8 sync_stat = 0; u8 alp_lock_stat[4] = {0}; u8 alp_lock_all = 0; u8 unlock_detected = 0; u8 num_plps = 0; u8 plpID[4] = {0}; u8 plp_lls[4] = {0}; u8 plp_lls_cnt= 0; sony_result_t resultscan; sony_atsc3_plp_list_entry_t plpList[SONY_ATSC3_NUM_PLP_MAX]={0}; sony_integ_atsc3_scan_param_t scan_param; scan_param.bandwidth = SONY_DTV_BW_6_MHZ; scan_param.startFrequencyKHz = (freqMHz*1000) ; scan_param.endFrequencyKHz = (freqMHz*1000) ; scan_param.stepFrequencyKHz = 6000; if(stc_init_flg==0){ /* Configure TS output format * When channel bonding is enable, it is necessary to set TS/TLV output to serial. * And TS serial clock should be set to 128MHz. */ /* Set TS output to parallel. Please see sony_demod.h in detail. */ result = sony_demod_SetConfig (&atsc_driver.demod, SONY_DEMOD_CONFIG_PARALLEL_SEL, 1); if (result != SONY_RESULT_OK) { log_printf(LOG_ERR,I_USER_CFG,"(result = %s)\n", Common_Result[result]); return -1; } else{ //printf(">>ok. Set TS output to parallel\n"); } /* Set TS output clock to 96MHz. Please see sony_demod.h in detail. */ result = sony_demod_SetConfig (&atsc_driver.demod, SONY_DEMOD_CONFIG_TERR_CABLE_TS_SERIAL_CLK_FREQ, 1); if (result != SONY_RESULT_OK) { log_printf(LOG_ERR,I_USER_CFG,"(result = %s)\n", Common_Result[result]); return -1; } /* Set demod output atsc3. */ result = sony_demod_SetConfig (&atsc_driver.demod, SONY_DEMOD_CONFIG_OUTPUT_ATSC3, 0); if (result != SONY_RESULT_OK) { log_printf(LOG_ERR,I_USER_CFG,"(result = %s)\n", Common_Result[result]); return -1; } } while(1) { if(tune_state==0) { #if 1 //for scan plp_list if(stc_init_flg==0){ resultscan = sony_integ_atsc3_Scan(&atsc_driver.integ,&scan_param,atsc3ScanCallbackHandler); if (resultscan != SONY_RESULT_OK) { printf(" 1.err, return integ_atsc3_Scan\n\n"); return -1; } else{ printf(" 1.ok, exc integ_atsc3_Scan\n\n"); } resultscan = sony_demod_atsc3_monitor_SyncStat(&atsc_driver.demod,&sync_stat,alp_lock_stat,&alp_lock_all,&unlock_detected); if (resultscan != SONY_RESULT_OK) { printf(" 2.err, return demod_atsc3_monitor_SyncStat\n\n"); return -1; } else{ printf(" 2.ok, exc demod_atsc3_monitor_SyncStat\n\n"); printf(" [%s,%d] sync=%d, alpLockStat=[%d-%d-%d-%d], alpLockAll=%d, unlockDetected=%d result=%d\n\n", __FUNCTION__,__LINE__, sync_stat, alp_lock_stat[0],alp_lock_stat[1],alp_lock_stat[2],alp_lock_stat[3], alp_lock_all, unlock_detected,resultscan); } resultscan = sony_demod_atsc3_monitor_PLPList(&atsc_driver.demod, plpList, &num_plps); if (resultscan != SONY_RESULT_OK) { printf(" 3.err %d, return demod_atsc3_monitor_PLPList\n\n",resultscan); return -1; } else{ printf(" 3.ok, exc demod_atsc3_monitor_PLPList\n\n"); plpinfos.actual_tun_plpnum = 0; plpinfos.plpnum = num_plps; g_tun_plpnum = plpinfos.plpnum; tuneParam3p0.centerFreqKHz = freqMHz*1000; /* Channel center frequency in KHz */ tuneParam3p0.bandwidth = SONY_DTV_BW_6_MHZ; /* Channel bandwidth */ tuneParam3p0.plpIDNum = num_plps; /* Number of valid PLP ID */ for(i=0;i<4;i++){ plpinfos.plplist[i].id = plpList[i].id; plpID[i]=plpList[i].id; tuneParam3p0.plpID[i] = plpList[i].id; /*if(plpList[i].lls_flg){ plpID[0] = i; //plp_lls[0] = i; }*/ } printf(" nplp=%d [%d,%d,%d,%d], lls_flg @id%d, plp set success\n\n",num_plps,plpList[0].id,plpList[1].id,plpList[2].id,plpList[3].id,plpID[0]); stc_init_flg=1; } } #endif /*tuneParam3p0.centerFreqKHz = (freqMHz*1000); tuneParam3p0.bandwidth = SONY_DTV_BW_6_MHZ; tuneParam3p0.plpIDNum = 1; tuneParam3p0.plpID[0] = 1;//0-Y, 1-N, 2-Y, 3-Y, 4-SEGMENT FAULT tuneParam3p0.plpID[1] = 0; tuneParam3p0.plpID[2] = 0; tuneParam3p0.plpID[3] = 0; printf("num=%d id=%d\n",tuneParam3p0.plpIDNum,tuneParam3p0.plpID[0]); */ RETRY_LESS_PLPNUM: result = sony_integ_atsc3_Tune (&atsc_driver.integ, &tuneParam3p0); if (result != SONY_RESULT_OK) { printf (" 4.err.integ_atsc3_Tune failed. plpnum=%d (result = %s) \n\n\n", tuneParam3p0.plpIDNum, Common_Result[result]); if(tuneParam3p0.plpIDNum>1){ sleep(1); tuneParam3p0.plpIDNum--; printf("retry plpnum%d init\n", tuneParam3p0.plpIDNum); goto RETRY_LESS_PLPNUM; } else{ printf("failed, retry plpnum%d init\n", tuneParam3p0.plpIDNum); clr_tun_done_flg(); stc_init_flg=0; } plpinfos.actual_tun_plpnum = 0; return -1; } else{ tmp_actual_tun_plpnum = tuneParam3p0.plpIDNum; plpinfos.actual_tun_plpnum = tmp_actual_tun_plpnum; set_tun_done_flg(); printf(" 4.ok, return demod_atsc3_SetPLPConfig act_tun_num=%d\n", plpinfos.actual_tun_plpnum); } resultscan = sony_demod_atsc3_monitor_SyncStat(&atsc_driver.demod, &sync_stat,alp_lock_stat,&alp_lock_all,&unlock_detected); if (resultscan != SONY_RESULT_OK) { printf(" 5.err, return demod_atsc3_monitor_SyncStat\n\n"); stc_init_flg=0; return -1; } else{ printf(" 5.ok, exc demod_atsc3_monitor_SyncStat\n\n"); printf(" 5.[%s,%d] sync=%d, alpLockStat=[%d-%d-%d-%d], alpLockAll=%d, unlockDetected=%d result=%d\n\n", __FUNCTION__,__LINE__, sync_stat, alp_lock_stat[0],alp_lock_stat[1],alp_lock_stat[2],alp_lock_stat[3], alp_lock_all, unlock_detected,resultscan); memset(&plpinfos,0,sizeof(plpinfos)); plpinfos.actual_tun_plpnum = tmp_actual_tun_plpnum; tune_state = 1; //return 0; } resultscan = sony_demod_atsc3_monitor_PLPList(&atsc_driver.demod, plpList, &num_plps); if (resultscan != SONY_RESULT_OK) { printf(" 6.err, return demod_atsc3_monitor_PLPList\n\n"); tune_state = 1; stc_init_flg=0; return 0; } else{ printf(" 6.ok, exc demod_atsc3_monitor_PLPList\n\n"); plpinfos.plpnum = num_plps; for(i=0;i<4;i++){ plpinfos.plplist[i].id = plpList[i].id; } printf(" 6.nplp=%d [%d,%d,%d,%d], lls_flg @id%d, plp set success\n\n",num_plps,plpList[0].id,plpList[1].id,plpList[2].id,plpList[3].id,plpID[0]); tune_state = 1; stc_init_flg=0; return 0; } } get_time(&tuner_tv_end); if(tuner_tv_end.tv_sec > (tuner_tv_start.tv_sec+TUNER_LOCK_CHECK_WAIT_SEC)){ if (resultscan != SONY_RESULT_OK){ log_printf(LOG_ERR,I_USER_CFG,"(result = %s) %d [%d,%d,%d,%d] \n", Common_Result[resultscan], num_plps, plpID[0], plpID[1], plpID[2], plpID[3]); } stc_init_flg=0; return -1; } usleep(1000*1000); } } } void tun_tuner_1plp_once() { sony_atsc3_tune_param_t tuneParam3p0={0}; if(get_tun_done_flg()==0){ printf(">> tun_tuner_1plp_once\n"); for(int i=0;i<4;i++){ tuneParam3p0.plpID[i] = plpinfos.plplist[i].id; } tuneParam3p0.centerFreqKHz = txfreq_to_hz(atsc_para.rf_para.rxfreq)*1000; /* Channel center frequency in KHz */ tuneParam3p0.bandwidth = SONY_DTV_BW_6_MHZ; /* Channel bandwidth */ tuneParam3p0.plpIDNum = 1; /* Number of valid PLP ID */ plpinfos.actual_tun_plpnum = 1; int result = sony_integ_atsc3_Tune (&atsc_driver.integ, &tuneParam3p0); if (result != SONY_RESULT_OK) { printf (">> err.tun_tuner_1plp_once failed. (result = %s) \n", Common_Result[result]); } else{ //printf(" nplp=%d [%d,%d,%d,%d], lls_flg plp set success\n\n",plpinfos.plpnum, // plpinfos.plplist[0].id,plpinfos.plplist[1].id,plpinfos.plplist[2].id,plpinfos.plplist[3].id); //printf(" ok, return demod_atsc3_SetPLPConfig\n"); } } } void usr_check_and_tun_tuner() { static sony_atsc3_tune_param_t tuneParam3p0={0}; int result; //teset------------------------------------- // plpinfos.plpnum=2; if(get_tun_done_flg()==1){ if(g_tun_plpnum==plpinfos.plpnum){ return ; } } printf("\n\n=====================usr_check_and_tun_tuner=last/check[%d/%d]===========================\n\n\n", g_tun_plpnum, plpinfos.plpnum); g_tun_plpnum = plpinfos.plpnum; for(int i=0;i<4;i++){ tuneParam3p0.plpID[i] = plpinfos.plplist[i].id; } tuneParam3p0.centerFreqKHz = txfreq_to_hz(atsc_para.rf_para.rxfreq)*1000; /* Channel center frequency in KHz */ tuneParam3p0.bandwidth = SONY_DTV_BW_6_MHZ; /* Channel bandwidth */ tuneParam3p0.plpIDNum = plpinfos.plpnum; /* Number of valid PLP ID */ printf("tun_cfg plpnum=%d id[%d %d %d %d]\n", tuneParam3p0.plpIDNum, tuneParam3p0.plpID[0],tuneParam3p0.plpID[1],tuneParam3p0.plpID[2],tuneParam3p0.plpID[3] ); _RETRY_LESS_TUN: result = sony_integ_atsc3_Tune (&atsc_driver.integ, &tuneParam3p0); if (result != SONY_RESULT_OK) { if(tuneParam3p0.plpIDNum>1){ sleep(1); tuneParam3p0.plpIDNum--; printf("retry plpnum%d init\n", tuneParam3p0.plpIDNum); goto _RETRY_LESS_TUN; } else{ plpinfos.actual_tun_plpnum = 0; printf("failed, retry plpnum%d init (result = %s)\n\n", tuneParam3p0.plpIDNum, Common_Result[result]); clr_tun_done_flg(); } } else{ plpinfos.actual_tun_plpnum = tuneParam3p0.plpIDNum; set_tun_done_flg(); printf(" ck_nplp=%d [%d,%d,%d,%d], lls_flg plp set success act_tun_num=%d\n\n",plpinfos.plpnum, plpinfos.plplist[0].id,plpinfos.plplist[1].id,plpinfos.plplist[2].id,plpinfos.plplist[3].id, plpinfos.actual_tun_plpnum); //printf(" ok, return demod_atsc3_SetPLPConfig\n"); } } int usr_update_atsc3_monitor_plpid(void) { int i; uint8_t num_plps; sony_result_t resultscan; sony_atsc3_plp_list_entry_t plpList[SONY_ATSC3_NUM_PLP_MAX]={0}; resultscan = sony_demod_atsc3_monitor_PLPList(&atsc_driver.demod, plpList, &num_plps); if (resultscan != SONY_RESULT_OK) { return -1; } plpinfos.plpnum = num_plps; for(i=0;i<4;i++){ plpinfos.plplist[i].id = plpList[i].id; } return 0; } int sonytuner_rssi(int *p_rssi, u8 atsc_ver) { if(atsc_ver==1) sony_cxd6801_tuner_rssi(&atsc_driver.integ, p_rssi); else sony_cxd6801_tuner_rssi_atsc3p0(&atsc_driver.integ, p_rssi); } int sonytuner_snr(int *p_snr, u8 atsc_ver) { if(atsc_ver==1) sony_cxd6801_snr(&atsc_driver.demod, p_snr); else{ sony_cxd6801_snr_atsc3p0(&atsc_driver.demod, p_snr); } } int sonytuner_tslock(uint8 *p_lock, u8 atsc_ver, u8 *p_sync_state, u8* p_alp_lock_all, u8* p_plperr) { if(p_lock==NULL || p_sync_state==NULL) return -1; if(atsc_ver==1) sony_cxd6801_tslock(&atsc_driver.demod, p_lock); else{ sony_cxd6801_tslock_atsc3p0(&atsc_driver.demod, p_lock, p_sync_state,p_alp_lock_all,p_plperr); } } int sonytuner_plperr(u8* p_plperr) { sony_result_t result; //p_plperr 0:all PLPs are founded, 1:not found result = sony_demod_atsc3_monitor_PLPError(&atsc_driver.demod, p_plperr); if(result!=SONY_RESULT_OK) { *p_plperr = 1; } return 0; }