hamaro_srbin.c

QPSK Tuner details, for conexant chipset.

                    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect SR - khz = ", delta_sr/1000);   
                    break;
            }  
        }
    }

    if (try_next_channel)
    {
        HAMARO_SetSymbolRate(hamaro_nim_list.nim[0],channel_info.symbol_rate_hz+delta_sr);

        while((clock() - start)<delta_tm*4)
        {
            if ((*addr)&0x02)
            {
                    try_next_channel = 0;
                    channel_info.symbol_rate_hz += delta_sr;
                    end = clock();
                    if (max_dmd_lock_detect_time<(end-start))
                        max_dmd_lock_detect_time = end-start;
                        
                    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect SR + khz = ", delta_sr/1000);   
                    break;
            }  
        }
    }
    
    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect Passed? ", !try_next_channel);
    end = clock();
    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect Time = ", end-start);    
    
    /* set aagc as the time value, only for test */
    //channel_info.aagc = end - start;
    channel_info.aagc = !try_next_channel;
    if(channel_index != 0)
    {
      STS_SetChannel(channel_info, channel_index-1);
    }
}

static void   
SRBIN_NextBinEnter()
{
    long cf = 0;
     
    if( try_next_channel )
    {
        return;
    }
    SRBIN_SetTimer1(); /* BTL lock timeout */
    SRBIN_SetTimer2(); /* Lock test timeout */
    SRBIN_SetTimer_us(); //need confirmation, no improvement.

    SrbinHighFlag = 0;
    SrbinLowFlag  = 0;
        
    //nom_sym_rate_hz = channel_info.symbol_rate_hz+SRBIN_BTL_MAX_ONE_SIDE_PPM_HIGH;// + sym_rate_bound;
    
                
    if (channel_info.symbol_rate_hz>35000000)
    {
        sym_rate_bound = 10000000;
        nom_sym_rate_hz = channel_info.symbol_rate_hz + 5000000;
        bin_timeout_msec = 180;
    }
    else if (channel_info.symbol_rate_hz>20000000)
    {
        sym_rate_bound = 8000000;
        nom_sym_rate_hz = channel_info.symbol_rate_hz + 4000000;
        bin_timeout_msec = 200;
    }
    else if (channel_info.symbol_rate_hz>10000000)
    {
        sym_rate_bound = 3000000;  
        nom_sym_rate_hz = channel_info.symbol_rate_hz + 3000000; 
        bin_timeout_msec = 250;
    }
    else if ( channel_info.symbol_rate_hz>3000000 )
    {
        nom_sym_rate_hz = channel_info.symbol_rate_hz+1400000;
        sym_rate_bound = 1400000;
        bin_timeout_msec = 450;
    }
    else
    {
        nom_sym_rate_hz = channel_info.symbol_rate_hz+800000;
        sym_rate_bound = 800000;
        bin_timeout_msec = 550;
    }
    
    if( nom_sym_rate_hz > SRBIN_MAX_SR_KHZ*1000)
    {
        nom_sym_rate_hz = SRBIN_MAX_SR_KHZ*1000;
    }
     
    //bin_timeout_msec = 400 - (float)nom_sym_rate_hz/1000*0.006;
    //trace("Timeout msec %d\n",bin_timeout_msec);
    
    if( bin_timeout_msec <= 0 )
    {
        bin_timeout_msec = 150;
    }
    
    SRBIN_FillOrderedSRTable(channel_info.symbol_rate_hz, sym_rate_bound/1000);
 
    STSDBG_WR_UNSIGNED("[nom_sym_rate_hz] = ", channel_info.symbol_rate_hz);//nom_sym_rate_hz);
    STSDBG_WR_UNSIGNED_LN(" | [freq_hz] = ", channel_info.carrier_freq_hz);
    
    
    
     if( channel_info.symbol_rate_hz >= SRBIN_MIN_SR_KHZ*1000 
        && channel_info.symbol_rate_hz <= SRBIN_MAX_SR_KHZ*1000)
    {
        volatile unsigned char *addr;
        
        addr = (volatile unsigned char *)0x304E000C;
        *addr = 0x00;
        SRBIN_ChangeChannel(channel_info.symbol_rate_hz);        
        
        try_next_channel = 1;
        HAMARO_GetCentralFreq(hamaro_nim_list.nim[0], &cf);
        STSDBG_WR_INT_LN("Central Freq = ",cf );
        SRBIN_NextBin_PreBin();
        
        /* try freq - 1M */
        if(try_next_channel)
        {
            HAMARO_SetCentralFreq(hamaro_nim_list.nim[0], cf-1000000);
            STSDBG_WR_STR("FREQ - 1M",True);
            SRBIN_NextBin_PreBin();
        }
        
        /* try freq + 1M */
        if(try_next_channel)
        {
            HAMARO_SetCentralFreq(hamaro_nim_list.nim[0], cf+1000000);
            STSDBG_WR_STR("FREQ + 1M",True);
            SRBIN_NextBin_PreBin();
        }
        
        addr = (unsigned char *)0x304E000C;
        *addr = 0x07;
    }
    else
    {
       try_next_channel = 1;
    }
    
    num_attempts = 0;    
}


static void   
SRBIN_NextBin() /* Regular task */
{
      unsigned long limit = 0;
      
      limit = channel_info.symbol_rate_hz - (sym_rate_bound);
      if (limit< SRBIN_MIN_SR_KHZ*1000)
          limit = SRBIN_MIN_SR_KHZ*1000;

    if (SRBIN_GetElapsedTime1MilliSec() >= bin_timeout_msec)
    {

        SRBIN_SetTimer1();
        
        if ((nom_sym_rate_hz - btl_bin_size_hz) < limit) //(channel_info.symbol_rate_hz - (sym_rate_bound))) /* reached limit */ 
        {
            if (num_attempts != max_num_attempts) /* Attempt few more cycles */
            {
                nom_sym_rate_hz = channel_info.symbol_rate_hz;// + sym_rate_bound;
                num_attempts++;
                STSDBG_WR_UNSIGNED("[Completed attempt] = ", num_attempts);
                STSDBG_WR_UNSIGNED_LN(" | [freq_MHz] = ", channel_info.carrier_freq_hz/1000000);
            }            
        }
        else
        {
            nom_sym_rate_hz = nom_sym_rate_hz - btl_bin_size_hz; /* Go in the positive direction only */
        }
        
        if (nom_sym_rate_hz < SRBIN_MIN_SR_KHZ*1000)
        {
            nom_sym_rate_hz = channel_info.symbol_rate_hz - (sym_rate_bound);
        }
        else
        {
            nom_sym_rate_hz = SRBIN_GetMatchedSR(nom_sym_rate_hz);
            if(nom_sym_rate_hz < SRBIN_MIN_SR_KHZ*1000)
            {
                if (num_attempts != max_num_attempts) /* Attempt few more cycles */
                {
                    nom_sym_rate_hz = channel_info.symbol_rate_hz;// + sym_rate_bound;
                    num_attempts++;
                    STSDBG_WR_UNSIGNED("[Completed attempt] = ", num_attempts);
                    STSDBG_WR_UNSIGNED_LN(" | [freq_MHz] = ", channel_info.carrier_freq_hz/1000000);
                }  
            }
            else
            {
                SRBIN_ChangeChannel(nom_sym_rate_hz);
                STSDBG_WR_UNSIGNED_LN("[nom_sym_rate_KHz] = ", nom_sym_rate_hz/1000);
            }
        }
    }
    
    if ((nom_sym_rate_hz==0) )//|| (sym_rate_bound==0))
            nom_sym_rate_hz = channel_info.symbol_rate_hz - (sym_rate_bound);
}

static BOOL   
SRBIN_NextBin2LockTestCriterion()
{
    HAMARO_LOCKIND lockinds;
    volatile unsigned char *addr;
    unsigned long reg_val;
    
     if ( !try_next_channel && SRBIN_GetElapsedTime1US() >= locktest_timeout_msec)
    {

        //SRBIN_SetTimer2(); /* Lock test timeout */
        SRBIN_SetTimer_us();
        
        addr = (unsigned char *)0x304e01B0;
        reg_val = *addr;
        
        reg_val &= !0x00000030;
        reg_val |= 0x10;        
        *addr = reg_val;
         
        if (STS_GetLockIndicators(&lockinds) == False)
        {
            return (False);
        }
        else
        {
            if (lockinds.syncbyte == True)
            {
                lock_achieved = True;
                return (True);
            }
        }
        
        reg_val = *addr;        
        reg_val &= !0x00000030;
        *addr = reg_val;
        
    }
    return (False);
}

static STATE* 
SRBIN_NextBin2LockTest()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_lock_test_state);
    return &sr_bin_lock_test_state;
}

static BOOL   
SRBIN_NextBin2CleanupCriterion()
{
    return (False);
}

static BOOL   
SRBIN_NextBin2NextChannelCriterion()
{
    if ((num_attempts >= max_num_attempts)||(try_next_channel == 1))
    {
        return (True);
    }
    return (False);
}

static STATE* 
SRBIN_NextBin2NextChannel()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_next_channel_state);
    return &sr_bin_next_channel_state;
}

static STATE* 
SRBIN_NextBin2Cleanup()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_cleanup_state);
    return &sr_bin_cleanup_state;
}

/* Symbol rate binning: Lock Test state */
static void   
SRBIN_LockTestEnter() 
{
    long btl = 0;
    long acq_offset = 0;
    unsigned long actual_sym_rate;

    STSDBG_WR_STR("-- CHANNEL LOCK --", True);
    
    STS_GetBTL(&btl);
    HAMARO_GetSymbolRate( hamaro_nim_list.nim[0],&actual_sym_rate );
    STSDBG_WR_INT_LN ("SYM RATE = ", actual_sym_rate);
    STS_GetAcquisitionOffset(&acq_offset);

    STSDBG_WR_INT_LN ("BTL = ", btl);
    channel_info.symbol_rate_hz = (unsigned long)((long)actual_sym_rate + btl);
    sr_last_known_good_khz = channel_info.symbol_rate_hz/1000;
    
    STSDBG_WR_UNSIGNED_LN ("Final symbol rate = ", channel_info.symbol_rate_hz);

    STSDBG_WR_INT_LN ("Acq offset = ", acq_offset);
    channel_info.carrier_freq_hz = (unsigned long)((long)channel_info.carrier_freq_hz + acq_offset);
    STSDBG_WR_UNSIGNED_LN ("Final carrier freq = ", channel_info.carrier_freq_hz);

    STS_GetViterbiRate(&channel_info.code_rate);
    STS_GetSpectralInversion(&channel_info.spec_inv);
    
    /* Following parameters are assumed */
    channel_info.mod_type  = HAMARO_MOD_QPSK;
    //channel_info.lnb_pol   = HAMARO_LNB_HIGH;
    HAMARO_GetLNBDC (hamaro_nim_list.nim[0], &channel_info.lnb_pol);
    channel_info.lnb_tone  = HAMARO_LNBTONE_OFF;
    channel_info.tran_spec = HAMARO_SPEC_DVB;

    channel_info.good_channel = True;

    if (channel_index != 0)
    {
        STS_SetChannel(channel_info, channel_index-1);
    }
}

static BOOL   
SRBIN_LockTest2NextChannelCriterion()
{
    if (lock_achieved == True)
    {
        return (True);
    }
    return (False);
}

static STATE* 
SRBIN_LockTest2NextChannel()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_next_channel_state);
    return &sr_bin_next_channel_state;
}

static void   
SRBIN_LockTest()
{
}

static void   
SRBIN_CleanupEnter()
{
    SRBIN_DumpChannelList("SRBIN_CleanupEnter",0);
    STS_ProgramAFC(SRBIN_DEFAULT_ACQ_AFC_EXPIRATION_WINDOW);
    STS_BTLAccumClearSelect(SRBIN_BTL_RESET_WHEN_REACQUIRE);
 
    //HAMARO_RegisterWrite(hamaro_nim_list.nim[0], CX2430X_ACQACCCLREN, 0x2C, HAMARO_DEMOD_I2C_IO);  

    STSDBG_WR_UNSIGNED_LN("STS_ProgramAFC() = ", SRBIN_DEFAULT_ACQ_AFC_EXPIRATION_WINDOW);
    
    STSDBG_WR_UNSIGNED_LN(" max_dmd_lock_detect_time = ", max_dmd_lock_detect_time);
    
    /* restore the Btl BandWidth value */
    HAMARO_RegisterWrite(hamaro_nim_list.nim[0],CX2430X_BTLBW,0, HAMARO_DEMOD_I2C_IO);
}

static BOOL   
SRBIN_Cleanup2ReadyCriterion()
{
    return (True);
}

static STATE* 
SRBIN_Cleanup2Ready()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_ready_state);
    return &sr_bin_ready_state;
}

/* Symbol rate binning: Ready state */
static void   
SRBIN_ReadyEnter()
{
    /* do nothing */
}

int SRBIN_GetMaxCandidateAAGC( void )
{
    int i;
    HAMARO_STS_CHANNEL_INFO temp_ch_info;
    int aagc,max_aagc;
    
    max_aagc =-128;
    for(i=0;i<max_channels;i++)
    {
        STS_GetChannel(i, &temp_ch_info);
        chan_obj.coderate   = HAMARO_CODERATE_3DIV4;
        chan_obj.frequency  = temp_ch_info.carrier_freq_hz;
        
        HAMARO_GetLNBDC (hamaro_nim_list.nim[0], &chan_obj.lnbpol);
        chan_obj.lnbtone    = HAMARO_LNBTONE_OFF;
        chan_obj.modtype    = HAMARO_MOD_QPSK;
        chan_obj.specinv    = HAMARO_SPEC_INV_OFF_BOTH;
        chan_obj.symbrate   = temp_ch_info.symbol_rate_hz/1000;
        chan_obj.transpec   = HAMARO_SPEC_DVB;
        chan_obj.viterbicoderates = (HAMARO_CODERATE_2DIV3 | HAMARO_CODERATE_1DIV2 |HAMARO_CODERATE_7DIV8 |
                                     HAMARO_CODERATE_4DIV5 | HAMARO_CODERATE_5DIV6 | HAMARO_CODERATE_6DIV7);
        
        STS_ChangeChannel(&chan_obj);
        task_time_sleep(50);
        HAMARO_GetAGCAcc(hamaro_nim_list.nim[0], &aagc);
        if( aagc > max_aagc )
        {
            max_aagc = aagc;
        }
    }
    
    return max_aagc;
}
#endif /* #if HAMARO_SCAN_THE_SKY */