void set_diversity_mode(struct dibDemod *demod[], int num)
{
USHORT val;
int i;
struct dib7000m_state *state;
for (i = num-1; i >= 0; i--) {
if(i!=0){
DibDbgPrint("-D- setting diversity out on for demod %d\n",i);
demod_set_output_mode(demod[i], OUTMODE_DIVERSITY);
}else{
DibDbgPrint("-D- setting normal output for demod %d\n",i);
demod_set_output_mode(demod[i], OUTMODE_MPEG2_PAR_GATED_CLK);
}
if(i!=num-1){
state = demod[i]->priv;
val = dib7000m_read_word(state, 900);
val |= 0x2000; // P_restart_dvin set
dib7000m_write_word(state, 900, val);
val &= 0xdfff; // P_restart_dvin clear
dib7000m_write_word(state, 900, val);
DibDbgPrint("-D- setting diversity in on for demod %d\n",i);
demod_set_diversity_in(demod[i], 1);
}else{
DibDbgPrint("-D- setting diversity in off for demod %d\n",i);
demod_set_diversity_in(demod[i], 0);
}
}
return;
}
struct dibI2CAdapter * open_spp_i2c()
{
///#ifdef TARGET_GOKE_DEVKIT
sppdesc = goke_spp_open();
///#else
/// sppdesc = linux_spp_open();
///#endif
if (sppdesc == NULL) {
#ifdef GD_FE_DIB7070_DEBUG01
DibDbgPrint("-E- SPP Linux could not be opened\n");
#endif
return NULL;
}
bus_adap = spp_i2c_attach(sppdesc,SPP_PORT,80);
if (bus_adap == NULL) {
#ifdef GD_FE_DIB7070_DEBUG01
DibDbgPrint("-E- SPP port could not be opened (addr: %03x)\n", SPP_PORT);
#endif
return NULL;
}
#ifdef GD_FE_DIB7070_DEBUG01
DibDbgPrint("-I- SPP successfully opened on port %03x\n", SPP_PORT);
#endif
return bus_adap->i2c_adap;
}
static int single_do_autosearch(struct dibDemod *demod, struct dibChannel *ch)
{
int ret,i=0, succeeded = 0;
if ((ret = demod_autosearch_start_ex(demod, ch)) != 0) {
DibDbgPrint("-E- starting autosearch failed for demod\n",i);
return ret;
}
for (i = 0; !succeeded && i < MAX_AUTOSEARCH_ITERATIONS; i++) {
switch (demod_autosearch_irq(demod)) {
case 0: break;
case 2:
DibDbgPrint("-I- Autosearch succeeded for demod - done.\n");
succeeded = 1;
break;
default:
DibDbgPrint("-E- Autosearch IRQ return unhandled value for demod.\n");
case 1: /* fall throught wanted */
DibDbgPrint("-I- Autosearch failed for demod - exluding from list.\n");
break;
}
if (succeeded)
break;
DibMSleep(1);
}
if (!succeeded) {
DibDbgPrint("-W- Autosearch failed for demod(s)\n");
return 1;
}
return demod_get_channel(demod,ch);
}
void sleep_single_tuner_and_demod(struct dibTuner *tuner, struct dibDemod *demod)
{
DibDbgPrint("-D- Slave tuner sleep\n");
tuner_sleep(tuner);
DibDbgPrint("-D- Slave demod sleep\n");
demod_sleep(demod);
return;
}
void set_single_mode(struct dibDemod *demod[], int num)
{
int i;
for (i = 0; i < num; i++) {
DibDbgPrint("-D- setting diversity in off for demod %d\n",i);
demod_set_diversity_in(demod[i], 0);
DibDbgPrint("-D- setting normal output for demod %d\n",i);
demod_set_output_mode(demod[i], OUTMODE_MPEG2_PAR_GATED_CLK);
}
}
U8 dib_lockstatus()
{
// int i;
//struct dibDVBSignalStatus status;
#ifdef DIB7000_DEMOD_7070Q
if (sip->demod->demod_info->ops.get_signal_status)
{
if (sip->demod->demod_info->ops.get_signal_status(sip->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
return 0;
}
}
#endif
#ifdef DIB7000_DEMOD_7070P
if(sip[0]->demod->demod_info->ops.get_signal_status)
{
if (sip[0]->demod->demod_info->ops.get_signal_status(sip[0]->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
return 0;
}
}
#endif
#ifdef DIB7000_DEMOD_7070M
if(sip[0]->demod->demod_info->ops.get_signal_status)
{
if (sip[0]->demod->demod_info->ops.get_signal_status(sip[0]->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
return 0;
}
}
#endif
#if 0
if(status.mpeg_data_lock != 0)
{
printf("......LOCK SUCCESS......\n");
}
else
{
printf("......LOCK FAIL......\n");
}
#endif
if((status.mpeg_data_lock==1)&&(status.tps_sync_lock)) return 1;
else return 0;
return status.mpeg_data_lock;
}
void dib_signal_strenth_quality(U8 *signal_quality, U8 *signal_strength)
{
struct dibDVBSignalStatus status;
// int i;
*signal_quality = 0;
*signal_strength = 0;
#ifdef DIB7000_DEMOD_7070Q
if (sip->demod->demod_info->ops.get_signal_status)
{
if (sip->demod->demod_info->ops.get_signal_status(sip->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
}
}
#endif
#ifdef DIB7000_DEMOD_7070P
if(sip[0]->demod->demod_info->ops.get_signal_status)
{
if (sip[0]->demod->demod_info->ops.get_signal_status(sip[0]->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
}
}
#endif
#ifdef DIB7000_DEMOD_7070M
if(sip[0]->demod->demod_info->ops.get_signal_status)
{
if (sip[0]->demod->demod_info->ops.get_signal_status(sip[0]->demod, &status) != 0)
{
DibDbgPrint("-E- Get signal status failed\n");
}
}
#endif
*signal_quality = (float)((float)(2097151 - (float)status.bit_error_rate)/2097151)*255 ;
*signal_strength = (U8)(153 + (255- 153)* ((status.signal_strength)/100.0));
if(*signal_quality < 1)
*signal_quality = 1;
else if (*signal_quality >255)
*signal_quality =255;
if(*signal_strength < 1)
*signal_strength = 1;
else if (*signal_strength >255)
*signal_strength =255;
}
void sleep_tuner_and_demod(struct dibTuner *tuner[], struct dibDemod *demod[], int num)
{
int i;
for (i = 0; i < num; i++) {
DibDbgPrint("-D- Sleep tuner %d\n", i);
tuner_sleep(tuner[i]);
DibDbgPrint("-D- Sleep demod %d\n",i);
demod_sleep(demod[i]);
}
return;
}
U8 dib_init()
{
struct dibI2CAdapter *i2c = open_dibcom_i2c();
DibZeroMemory(mon, sizeof(mon));
if (i2c == NULL)
return 1;
#ifdef DIB7000_DEMOD_7070Q
// if (dib7070q_attach(i2c, DIB7070PA_DEFAULT_I2C_ADDRESS, &tfe7070q_config) != DIB_RETURN_SUCCESS)
if ((sip = dib7070q_attach(i2c, DIB7070PA_DEFAULT_I2C_ADDRESS, &tfe7070q_config)) == NULL)
#endif
#ifdef DIB7000_DEMOD_7070P
if (dib7070pa_attach(i2c, NUM_OF_DEMOD, DIB7070PA_DEFAULT_I2C_ADDRESS, nim7070p_config, sip) != DIB_RETURN_SUCCESS)
#endif
#ifdef DIB7000_DEMOD_7070M
if (dib7070ma_attach(i2c, NUM_OF_DEMOD, DIB7070MA_DEFAULT_I2C_ADDRESS, nim7070md_config, sip) != DIB_RETURN_SUCCESS)
#endif
{
DibDbgPrint("-E- DiB7070P: attaching demod and tuners failed.\n");
return 1;
}
return 0;
}
void host_i2c_release(struct dibDataBusHost *i2c_adap)
{
struct i2c_state *state = i2c_adap->priv;
DibDbgPrint("-I- closing I2C\n");
MemFree(state, sizeof(struct i2c_state));
}
static int do_autosearch(struct dibDemod *demod[], int num, struct dibChannel *ch)
{
int ret=0,i=0,k=0,stat = 0, num_failed = 0, succeeded = 0;
for (i = 0; i < num; i++) {
if ((ret = demod_autosearch_start_ex(demod[i], ch)) != 0) {
DibDbgPrint("-E- starting autosearch failed for demod %d\n",i);
return ret;
}
}
for (i = 0; !succeeded && num != num_failed && i < MAX_AUTOSEARCH_ITERATIONS; i++) {
for (k = 0; k < num; k++) {
if (!(stat & (1 << k))) { // if not already excluded from autosearch
switch (demod_autosearch_irq(demod[k])) {
case 0:
break;
case 2:
DibDbgPrint("-I- Autosearch succeeded for demod %d - done.\n",k);
succeeded = 1;
break;
default:
DibDbgPrint("-E- Autosearch IRQ return unhandled value for demod %d.\n",k);
case 1: /* fall throught wanted */
DibDbgPrint("-I- Autosearch failed for demod %d - exluding from list.\n",k);
stat |= (1 << k);
num_failed++;
break;
}
if (succeeded)
break;
}
}
DibMSleep(1);
}
if (!succeeded) {
DibDbgPrint("-W- Autosearch failed for %d demod(s)\n",num_failed);
return 1;
}
return demod_get_channel(demod[k],ch);
}
signed long tuner_dec_use_count(struct dibTuner *tuner, signed long count)
{
tuner->use_count -= count;
if (tuner->use_count < 0) {
tuner->use_count = 0; //To be modified ASAP
#ifdef GD_FE_DIB7070_DEBUG01
DibDbgPrint("-E- tuner use_count is below zero - something is wrong\n");
#endif
return DIB_RETURN_ERROR;
}
return DIB_RETURN_SUCCESS;
}
signed long dib7000m_enable_vbg_voltage(struct dibDemod *demod)
{
struct dib7000m_state *state = demod->priv;
#ifdef GD_FE_DIB7070_DEBUG01
DibDbgPrint("-D- Enabling VBG voltage in the ADC\n");
#endif
/* P_dual_adc_cfg0 */
dib7000m_write_word(state, 913, 0x0000);
/* P_dual_adc_cfg1 = 3, P_sar_adc_cfg = 2 */
dib7000m_write_word(state, 914, (3 << 2) | (2 << 0));
return DIB_RETURN_SUCCESS;
}
int tune_single_tuner_and_demod_channel(struct dibTuner *tuner, struct dibDemod *demod, struct dibChannel *ch)
{
int time, ret;
if (demod_init(demod) != 0) {
DibDbgPrint("-E- Demod init failed\n");
return 1;
}
if (tuner_init(tuner) != 0) {
DibDbgPrint("-E- Tuner init failed\n");
return 1;
}
if (tuner_set_bandwidth_ex(tuner, ch) != 0) {
DibDbgPrint("-E- Tuner set_bandwidth failed\n");
return 1;
}
if (tuner_tune(tuner, ch) != 0) {
DibDbgPrint("-E- Tuner tune_digital failed\n");
return 1;
}
/* prepare the agc startup loop */
demod_agc_restart(demod);
do {
time = -1;
ret = demod_agc_startup_ex(demod, ch);
if (ret > time)
time = ret;
if (time != -1)
DibMSleep(time);
} while (time != -1);
if ((ch->type == STANDARD_DVBT && (ch->u.dvbt.nfft == FFT_AUTO || ch->u.dvbt.guard == GUARD_INTERVAL_AUTO || ch->u.dvbt.constellation == QAM_AUTO ||
ch->u.dvbt.intlv_native == INTLV_NATIVE_AUTO || ch->u.dvbt.hrch == VIT_HRCH_AUTO || ch->u.dvbt.select_hp == VIT_PRIORITY_AUTO ||
ch->u.dvbt.alpha == VIT_ALPHA_AUTO || ch->u.dvbt.code_rate_hp == VIT_CODERATE_AUTO ||
((ch->u.dvbt.hrch == VIT_HRCH_ON && ch->u.dvbt.code_rate_lp == VIT_CODERATE_AUTO)))) ||
((ch->type == STANDARD_ISDBT) && (ch->u.isdbt.nfft == FFT_AUTO || ch->u.isdbt.guard == GUARD_INTERVAL_AUTO)))
if (single_do_autosearch(demod, ch) != 0) {
DibDbgPrint("-W- autosearching parameters failed.\n");
return 1;
}
dump_dvb_channel_params(ch);
if (demod_tune_ex(demod,ch) != 0){
DibDbgPrint("-W- tuning failed for demod - this is just a warning could be normal in diversity.\n");
return 1;
}
return 0;
}
void linux_spp_close(struct dibSPPDescriptor *desc)
{
struct linux_spp_state *st = desc->priv;
DibDbgPrint("-I- closing SPP\n");
MemFree(st,sizeof(struct linux_spp_state));
}
/* example of creating all the demod-structure and tuner-structures and tuning them in diversity and start monitoring after that */
int main(int argc, char *argv[])
{
struct dibI2CAdapter *main_i2c = open_spp_i2c();
struct dibI2CAdapter *tuner_i2c[2];
struct dibDemod *demod[2];
struct dibTuner *tuner[2];
struct dibDemodMonitor mon[2];
struct dibDVBChannel ch;
DibZeroMemory(mon, sizeof(mon));
if (main_i2c == NULL)
return 1;
/* attach 2 demods, do i2c-enumeration */
if (dib7000p_attach(main_i2c, 2, DEFAULT_DIB7000P_I2C_ADDRESS, 1, dib7000p_example_board_config, demod) != 0) {
DibDbgPrint("-E- dib7000 attaching and i2c enumeration failed.\n");
exit(1);
}
/* first tuner */
tuner_i2c[0] = dib7000p_get_i2c_master(demod[0], DIBX000_I2C_INTERFACE_TUNER, 1);
if ((tuner[0] = env57h12d5_attach(tuner_i2c[0], &tuner_0_config)) == NULL) {
DibDbgPrint("-E- env57h12d5 -0- attaching failed.\n");
exit(1);
}
/* second tuner */
tuner_i2c[1] = dib7000p_get_i2c_master(demod[1], DIBX000_I2C_INTERFACE_TUNER, 1);
if ((tuner[1] = env57h12d5_attach(tuner_i2c[1], &tuner_1_config)) == NULL) {
DibDbgPrint("-E- env57h12d5 -1- attaching failed.\n");
exit(1);
}
INIT_DVB_CHANNEL(&ch);
ch.RF_kHz = 474000;
ch.Bw = INDEX_BW_8_0_MHZ;
/* tune the 2 demods and tuner to the channel "ch" */
tune_diversity_tuner_and_demod(tuner,demod,2,&ch);
DibDbgPrint("-I- Tuning done <enter>\n");
getchar();
while (1) {
/* get monitoring information for the first demod */
demod_get_monitoring(demod[0], &mon[0]);
/* get monitoring information for the second demod */
demod_get_monitoring(demod[1], &mon[1]);
/* display information for 2 demods */
dib7000_print_monitor(mon, NULL, 0, 2);
usleep(100000);
}
DibDbgPrint("-I- Cleaning up\n");
/* release the 2 tuners */
tuner_release(tuner[1]);
tuner_release(tuner[0]);
/* release the 2 demods */
demod_release(demod[1]);
demod_release(demod[0]);
close_spp_i2c();
return 0;
}
/* example of creating all the demod-structure and tuner-structures and tuning them in diversity and start monitoring after that */
int main(int argc, char *argv[])
{
struct dibI2CAdapter *main_i2c = open_spp_i2c();
struct dibI2CAdapter *tuner_i2c[2];
struct dibDemod *demod[2];
struct dibTuner *tuner[2];
struct dibDemodMonitor mon[2];
struct dibDVBChannel ch;
DibZeroMemory(mon, sizeof(mon));
if (main_i2c == NULL)
return 1;
if (dib7000m_attach(main_i2c, 2, DEFAULT_DIB7000M_I2C_ADDRESS, 1, dib7000m_demod_config, demod) != 0) {
DibDbgPrint("-E- dib7000 attaching and i2c enumeration failed.\n");
exit(1);
}
tuner_i2c[0] = dib7000m_get_i2c_master(demod[0], DIBX000_I2C_INTERFACE_TUNER, 1);
if ((tuner[0] = env57h12d5_attach(tuner_i2c[0], &tuner_0_config)) == NULL) {
DibDbgPrint("-E- env57h12d5 -0- attaching failed.\n");
exit(1);
}
tuner_i2c[1] = dib7000m_get_i2c_master(demod[1], DIBX000_I2C_INTERFACE_TUNER, 1);
if ((tuner[1] = env57h12d5_attach(tuner_i2c[1], &tuner_1_config)) == NULL) {
DibDbgPrint("-E- env57h12d5 -1- attaching failed.\n");
exit(1);
}
INIT_DVB_CHANNEL(&ch);
ch.RF_kHz = 474000;
ch.Bw = INDEX_BW_8_0_MHZ;
tune_diversity_tuner_and_demod(tuner,demod,2,&ch);
DibDbgPrint("-I- Tuning done <enter>\n");
getchar();
while (1) {
demod_get_monitoring(demod[0], &mon[0]);
demod_get_monitoring(demod[1], &mon[1]);
dib7000_print_monitor(mon, NULL, 0, 2);
usleep(100000);
}
DibDbgPrint("-I- Cleaning up\n");
tuner_release(tuner[1]);
tuner_release(tuner[0]);
demod_release(demod[1]);
demod_release(demod[0]);
close_spp_i2c();
return 0;
}
void DemodRegDump(struct dibDemod *demod[])
{
uint16_t i;
struct dib7000m_state *state;
state = demod[0]->priv;
DibDbgPrint("demod0-Add 0~331\n");
for(i=0;i<332;i++) DibDbgPrint("demod0-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod0-Add 384~536\n");
for(i=384;i<537;i++) DibDbgPrint("demod0-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod0-Add 768~781\n");
for(i=768;i<782;i++) DibDbgPrint("demod0-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod0-Add896~934\n");
for(i=896;i<935;i++) DibDbgPrint("demod0-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
state = demod[1]->priv;
DibDbgPrint("\ndemod1-Add 0~331\n");
for(i=0;i<332;i++) DibDbgPrint("demod1-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod1-Add 384~536\n");
for(i=384;i<537;i++) DibDbgPrint("demod1-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod1-Add 768~781\n");
for(i=768;i<782;i++) DibDbgPrint("demod1-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
DibDbgPrint("demod1-Add896~934\n");
for(i=896;i<935;i++) DibDbgPrint("demod1-Add:%3d - 0x%04X\n",i, dib7000m_read_word(state, i));
}
void GetVer()
{
DibDbgPrint("DiBcom SDK Version 2.1.5\n");
}
/* both demods are on the same I2C-bus by default accessible through address 18 */
int main (void)
{
// default I2C implementation is based on parallel port but user can connect its
// own I2C driver using host_i2c_interface_attach();
// implementation is done in sample/interface/host.c
//struct dibDataBusHost *i2c = host_i2c_interface_attach(NULL), *b;
struct dibDataBusHost *i2c = open_spp_i2c(), *b;
struct dibFrontend frontend[2];
struct dibChannel ch;
struct dibDemodMonitor mon[2];
struct dibPMU *pmu;
if (i2c == NULL)
return 1;
DibZeroMemory(&mon, sizeof(mon));
frontend_init(&frontend[0]); /* initializing the frontend-structure */
frontend_init(&frontend[1]); /* initializing the frontend-structure */
frontend_set_id(&frontend[0], 0); /* assign an absolute ID to the frontend */
frontend_set_id(&frontend[1], 1); /* assign an absolute ID to the frontend */
if (dib9090_firmware_sip_register(&frontend[0], 0x80, i2c, &nim9090md_config[0]) == NULL) { /* using a frontend on I2C address 0x80 */
dbgp(" DiB9090: attaching demod and tuners failed.\n");
return DIB_RETURN_ERROR;
}
i2c = dib7000m_get_i2c_master(&frontend[0], DIBX000_I2C_INTERFACE_GPIO_3_4, 0);
if (dib9090_firmware_sip_register(&frontend[1], 0x82, i2c, &nim9090md_config[1]) == NULL) { /* using a frontend on I2C address 0x82 */
dbgp(" DiB9090: attaching demod and tuners failed.\n");
return DIB_RETURN_ERROR;
}
/* do the i2c-enumeration for 2 demod and use 0x80 as the I2C address for first device */
i2c = data_bus_client_get_data_bus(demod_get_data_bus_client(&frontend[0]));
dib7000m_i2c_enumeration(i2c, 1, 0x20, 0x80); /* non-standard i2c-enumeration, because of INT_SELECT-fixation */
i2c = data_bus_client_get_data_bus(demod_get_data_bus_client(&frontend[1]));
dib7000m_i2c_enumeration(i2c, 1, DEFAULT_DIB9000_I2C_ADDRESS, 0x82);
b = dib7000m_get_i2c_master(&frontend[0], DIBX000_I2C_INTERFACE_GPIO_1_2, 0);
if ((pmu = osiris_create(b, &nim9090md_osiris_config)) == NULL)
return DIB_RETURN_ERROR;
dib9090_set_pmu(&frontend[0], pmu); /* workaround because we cannot access the PMU from the host after downloading the firmware - for now */
frontend_reset(&frontend[0]);
frontend_reset(&frontend[1]);
INIT_CHANNEL(&ch, STANDARD_DVBT);
ch.RF_kHz = 474000;
ch.bandwidth_kHz = 8000;
/* just to set them in a known state - not important */
tune_diversity(frontend, 2, &ch);
DibDbgPrint("-I- Tuning done <enter>\n");
getchar();
while (1) {
/* after enumerating on the same i2c-bus, the i2c-addresses of the bus will be 0x80 for the diversity master and 0x82 for the slave */
demod_get_monitoring(&frontend[0], &mon[0]);
demod_get_monitoring(&frontend[1], &mon[1]);
dib7000_print_monitor(mon, NULL, 0 ,2);
usleep(100000);
}
DibDbgPrint("-I- Cleaning up\n");
frontend_unregister_components(&frontend[1]);
frontend_unregister_components(&frontend[0]);
pmu_release(pmu);
//host_i2c_release(i2c);
close_spp_i2c();
return 0;
}
/* tune (do autosearch in case of unknown parameters) */
void tune_diversity_tuner_and_demod_channel(struct dibTuner *tuner[], struct dibDemod *demod[], int num, struct dibChannel *ch)
{
int i, time, ret;
for (i = 0; i < num; i++) {
if (demod_init(demod[i]) != 0) {
DibDbgPrint("-E- Tuner init failed\n");
return;
}
if (tuner_init(tuner[i]) != 0) {
DibDbgPrint("-E- Tuner init failed\n");
return;
}
}
for (i = 0; i < num; i++) {
if (tuner_set_bandwidth_ex(tuner[i], ch) != 0) {
DibDbgPrint("-E- Tuner set_bandwidth failed\n");
return;
}
if (tuner_tune(tuner[i], ch) != 0) {
DibDbgPrint("-E- Tuner tune_digital failed\n");
return;
}
/* prepare the agc startup loop */
demod_agc_restart(demod[i]);
}
do {
time = -1;
for (i = 0; i < num; i++) {
ret = demod_agc_startup_ex(demod[i], ch);
if (ret > time)
time = ret;
}
if (time != -1)
DibMSleep(time);
} while (time != -1);
if ((ch->type == STANDARD_DVBT && (ch->u.dvbt.nfft == FFT_AUTO || ch->u.dvbt.guard == GUARD_INTERVAL_AUTO || ch->u.dvbt.constellation == QAM_AUTO ||
ch->u.dvbt.intlv_native == INTLV_NATIVE_AUTO || ch->u.dvbt.hrch == VIT_HRCH_AUTO || ch->u.dvbt.select_hp == VIT_PRIORITY_AUTO ||
ch->u.dvbt.alpha == VIT_ALPHA_AUTO || ch->u.dvbt.code_rate_hp == VIT_CODERATE_AUTO ||
((ch->u.dvbt.hrch == VIT_HRCH_ON && ch->u.dvbt.code_rate_lp == VIT_CODERATE_AUTO)))))
if (do_autosearch(demod, num, ch) != 0) {
DibDbgPrint("-W- autosearching parameters failed.\n");
return;
}
dump_dvb_channel_params(ch);
for (i = 0; i < num; i++) {
if (demod_tune_ex(demod[i],ch) != 0)
DibDbgPrint("-W- tuning failed for demod - this is just a warning could be normal in diversity.\n");
}
for (i = 0; i < num; i++) {
if (i == num-1) { // last demod in a diversity chain - turn off div-in combination
DibDbgPrint("-D- setting diversity in off for demod %d\n",i);
demod_set_diversity_in(demod[i], 0);
} else {
DibDbgPrint("-D- setting diversity in on for demod %d\n",i);
demod_set_diversity_in(demod[i], 1);
}
if (i == 0) { // first demod in a diversity chain - no diversity output
DibDbgPrint("-D- setting normal output for demod %d\n",i);
demod_set_output_mode(demod[i], OUTMODE_MPEG2_PAR_GATED_CLK);
} else {
DibDbgPrint("-D- setting diversity out on for demod %d\n",i);
demod_set_output_mode(demod[i], OUTMODE_DIVERSITY);
}
}
return;
}
uint16_t frontend_get_isdbt_sb_channels(struct dibFrontend *fe[], uint32_t freq , uint32_t bw, int num, struct dibChannel ch[])
{
uint16_t seg_bw_khz = 429;
int16_t rf_offset_khz = 0;
uint16_t total_segment_number = (uint16_t)((bw / seg_bw_khz) - 1); // 1 is the freq guard
int segment_index = 0, channel_index = 0, subch_id = -1;
int i;
dbgpl(NULL, "will search SB on %d potential segment(s) inside a bandwidth of %dkhz arround FR freq %dkhz", total_segment_number, bw, freq);
for (i = 0; i < num; i++) {
if (demod_init(fe[i]) != 0) {
DibDbgPrint("-E- Tuner init failed\n");
return 0;
}
if (tuner_init(fe[i]) != 0) {
DibDbgPrint("-E- Tuner init failed\n");
return 0;
}
}
for (segment_index = 1; segment_index <= total_segment_number; segment_index++) {
int success, fe_fail_count;
channel_init(&ch[channel_index], STANDARD_ISDBT);
/* compute segment center freq */
rf_offset_khz = seg_bw_khz * (segment_index - (total_segment_number/2) - (total_segment_number%2));
dbgpl(NULL,"rf_offset_khz = %d",rf_offset_khz);
/* add a half of seg BW offset is total number of connected seg is even */
if((total_segment_number%2) == 0) {
dbgpl(NULL,"compensate for 1/2 seg (%d khz) tune freq because sb_conn_total_seg is even = %d",seg_bw_khz, total_segment_number);
rf_offset_khz-=(seg_bw_khz/2);
}
dbgpl(NULL,"rf_offset_khz = %d",rf_offset_khz);
ch[channel_index].RF_kHz = freq + rf_offset_khz;
ch[channel_index].bandwidth_kHz = bw;
ch[channel_index].u.isdbt.sb_mode = 1;
if (subch_id != -1)
subch_id += 3;
ch[channel_index].u.isdbt.sb_subchannel = subch_id;
dbgpl(NULL,"---------------------- Start search on segment #%d center freq = %dkhz (%d+%d, %d)--------------------- ",
segment_index,ch[channel_index].RF_kHz, freq, rf_offset_khz, subch_id);
for (i = 0; i < num; i++)
frontend_tune_restart(fe[i], FE_RESTART_TUNE_PROCESS_FROM_TUNER, &ch[channel_index]);
do {
success = 0;
fe_fail_count = 0;
for (i = 0; i < num; i++) {
frontend_tune(fe[i], &ch[channel_index]);
if (fe[i]->status_has_changed && (frontend_get_status(fe[i]) == FE_STATUS_DEMOD_SUCCESS || frontend_get_status(fe[i]) == FE_STATUS_FFT_SUCCESS)) {
//dbgpl(&adapter_dbg, "Autosearch succeeded on FE %d", fe[i]->id);
frontend_get_channel(fe[i], &ch[channel_index]); /* we read the channel parameters from the frontend which was successful */
if (ch[channel_index].u.isdbt.partial_reception == 1) {
ch[channel_index].bandwidth_kHz = seg_bw_khz * 3; /* bandwidth is for 3 segments */
segment_index++; /* no need to check the next segment */
} else
ch[channel_index].bandwidth_kHz = seg_bw_khz;
#ifdef DIBCOM_EXTENDED_MONITORING
dump_digital_channel_params(&ch[channel_index]);
#endif
}
if (frontend_get_status(fe[i]) == FE_STATUS_LOCKED) {
subch_id = ch[channel_index].u.isdbt.sb_subchannel;
channel_index++;
success = 1;
break;
} else if(frontend_get_status(fe[i]) == FE_STATUS_TUNE_FAILED) {
fe_fail_count++;
}
}
} while (!success && fe_fail_count != num);
if (success)
DibDbgPrint("-I- Autosearch succeeded for demod %d channel_index = %d - done.\n",i, channel_index);
else
DibDbgPrint("-I- Autosearch failled for demod %d channel_index = %d - done. %d/%d\n",i, channel_index, fe_fail_count, num);
}
return channel_index;
}
