hamaro_srbin.c

QPSK Tuner details, for conexant chipset.

    if (channel_index < max_channels)
    {
          STS_GetChannel(channel_index, &channel_info);
        /* Check whether the candidate is duplicate fingding */
        for( i=0; i < channel_index; i++ )
        {
            STS_GetChannel( i, &temp_ch_info );
            temp_fr1 = temp_ch_info.carrier_freq_hz - temp_ch_info.symbol_rate_hz/2 - 2000000;
            temp_fr2 = temp_ch_info.carrier_freq_hz + temp_ch_info.symbol_rate_hz/2 + 2000000;
            if( temp_ch_info.good_channel && temp_fr1 < channel_info.carrier_freq_hz
                && channel_info.carrier_freq_hz <  temp_fr2)
            {
                /* it's a tp already found, try next channel */
                channel_index++;
                try_next_channel = 1;
                STSDBG_WR_STR("This is a tp already found, tyr next channel",True);
                return;
            }
        }
        
        btl_bin_size_hz = btl_bin_size_ppm;
        
        sym_rate_bound = SRBIN_BTL_MAX_ONE_SIDE_PPM_HIGH;
        


        STSDBG_WR_UNSIGNED_LN("btl_bin_size_hz = ",  btl_bin_size_hz);
        STSDBG_WR_UNSIGNED_LN("sym_rate_bound = ",   sym_rate_bound);
            
        chan_obj.coderate   = HAMARO_CODERATE_3DIV4;
        chan_obj.frequency  = channel_info.carrier_freq_hz;
        
        HAMARO_GetLNBDC (hamaro_nim_list.nim[0], &chan_obj.lnbpol);
        //chan_obj.lnbpol     = HAMARO_LNB_HIGH; /* Also HAMARO_LNB_LOW */
        chan_obj.lnbtone    = HAMARO_LNBTONE_OFF;
        chan_obj.modtype    = HAMARO_MOD_QPSK;
        chan_obj.specinv    = HAMARO_SPEC_INV_OFF_BOTH;
        chan_obj.symbrate   = channel_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);


        bin_timeout_msec = 320;//320 - channel_info.symbol_rate_hz*6/1000000; 

        channel_index++;
    }
    else
    {
         more_channels = False;
    }
}

static BOOL   
SRBIN_NextChannel2NextBinCriterion()
{
    if ((more_channels == True) && (channel_index <= max_channels))
    {
        return (True);
    }
    return (False);
}

static STATE* 
SRBIN_NextChannel2NextBin()
{
    DBG_CHECK_FSM_LIMITS(&sr_bin_next_bin_state);
    return &sr_bin_next_bin_state;    
}

static BOOL   
SRBIN_NextChannel2CleanupCriterion()
{
    if ((more_channels == False)||(channel_index > max_channels))
    {
        return (True);
    }
    return (False);
}

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

/*****************************************************************************/
/*       TIMING FUNCTIONS.                                                   */
/*****************************************************************************/
typedef struct _trace_time_t
{
    u_int32 min, sec, msec, nsec;
} trace_time_t;

unsigned long srbin_clock_us()
{    
	extern void trace_timestamp(trace_time_t *time);
	trace_time_t dmd_time;	
	trace_timestamp(&dmd_time);
	return (dmd_time.min*60000000+dmd_time.sec*1000000+dmd_time.msec*1000+dmd_time.nsec/1000);
}
static clock_t start_us;
static void 
SRBIN_SetTimer_us(void)
{
    start_us = srbin_clock_us();
}

static unsigned short 
SRBIN_GetElapsedTime1US(void)
{
    clock_t finish;
    unsigned short duration;
  
    finish = srbin_clock_us();
    duration = (unsigned short)(finish - start_us);
    return duration;
}



static clock_t start1, start2;
static void 
SRBIN_SetTimer1(void)
{
    start1 = clock();
}

static void 
SRBIN_SetTimer2(void)
{
    start2 = clock();
}

static unsigned short 
SRBIN_GetElapsedTime1MilliSec(void)
{
    clock_t finish;
    unsigned short duration;
  
    finish = clock();
    duration = (unsigned short)(finish - start1);
    return duration;
}

static unsigned short 
SRBIN_GetElapsedTime2MilliSec(void)
{
    clock_t finish;
    unsigned short duration;
  
    finish = clock();
    duration = (unsigned short)(finish - start2);
    return duration;
}


/*****************************************************************************/
/*                      END OF TIMING FUNCTIONS.                             */
/*****************************************************************************/

/* Symbol rate binning: Next bin state */

static unsigned short locktest_timeout_msec = SRBIN_LOCKTEST_TIMEOUT_MSEC;
static unsigned char  max_num_attempts = SRBIN_MAX_ATTEMPTS_PER_CHANNEL;
static unsigned char  num_attempts;
extern BOOL PWRSCAN_BTLAccClear();
static void
SRBIN_ChangeChannel(unsigned long nominal_symbol_rate_hz)
{   
    chan_obj.symbrate = nominal_symbol_rate_hz/1000UL;
    PWRSCAN_BTLAccClear(); 
    
    STS_ChangeChannel(&chan_obj);
}

#if 0
static unsigned long SRBIN_GetMatchedSR(unsigned long sr_hz)
{
    unsigned short i=0;
    
    sr_hz /= 1000;
    
    while(i<known_symbol_rate_num)
    {
        if (known_symbol_rate_table[i]<=sr_hz)
            break;
        
        i++;    
    }
    
    if( i >= known_symbol_rate_num )
    {
        return 0;
    }
    
    return known_symbol_rate_table[i] * 1000;
}
#else
static u_int16 reorder_symbol_rate_current = 0;
static unsigned long sr_last_known_good_khz = 0;
#define SR_DIFF_KHZ 300

static int32 SRBIN_FillOrderedSRTable(unsigned long sr_hz, unsigned long range_k)
{
    unsigned short i=0, j=0;
    int32 upper=0, low=0;
    unsigned short lasti=0, lastj=0, ppm=0;
    unsigned short idone=FALSE, jdone=FALSE, jcont=FALSE;
    
    sr_hz /= 1000;
    
    while(i<known_symbol_rate_num)
    {
        if (known_symbol_rate_table[i]<= (sr_hz-SR_DIFF_KHZ) )
            break;
        
        i++;    
    }
    
    reorder_symbol_rate_count = 0;
    reorder_symbol_rate_current = 0;
    
    ppm = sr_hz/100;//300;
    
    if( ppm > 150 )
    {
        ppm = 150;
    }
    
    if (i==known_symbol_rate_num)
        return (-1);
    
    j = i - 1;
    if( i == 0 )
    {
        j=0;
    }
    
    upper = sr_hz + range_k;
    low = sr_hz - range_k;
  STSDBG_WR_UNSIGNED(" [ppm] = ", ppm);
  STSDBG_WR_UNSIGNED(" | [low] = ", low);
  STSDBG_WR_UNSIGNED_LN(" | [upper] = ", upper);
  
    if (low < 0)
        low = 0;
    if (upper > known_symbol_rate_table[0])
        upper = known_symbol_rate_table[0];
    
    if( sr_last_known_good_khz > low && sr_last_known_good_khz < upper  )
    {
        reorder_symbol_rate_table[reorder_symbol_rate_count++]= sr_last_known_good_khz;
    }
    lasti = known_symbol_rate_table[i] + ppm + 10;
        
    while(1)
    {
        if (j==0)
            jdone = TRUE;
            
        if (i>=known_symbol_rate_num)
            idone = TRUE;
        
        if (reorder_symbol_rate_count>=REORDER_SYMBOL_RATE_NUMBER)
            break;
        
        if (jcont==FALSE)
        {    
            if ((known_symbol_rate_table[i] > low)&&(idone==FALSE))
            {
                  if ((lasti-known_symbol_rate_table[i]) > ppm)
                  {
                    lasti = known_symbol_rate_table[i];
                    reorder_symbol_rate_table[reorder_symbol_rate_count++]= known_symbol_rate_table[i];
                }
                else
                {
                    i++;
                    continue;
                }
            }
            else
            {
                idone = TRUE;
            }
      }
        if ((known_symbol_rate_table[j] < upper)&&(jdone==FALSE))
        {
              if ((known_symbol_rate_table[j]- lastj) > ppm)
              {
                 lastj = known_symbol_rate_table[j];
               reorder_symbol_rate_table[reorder_symbol_rate_count++]= known_symbol_rate_table[j];
               jcont = FALSE;
            }
            else
            {
                j--;
                jcont = TRUE;
            continue;
            }
        }
        else
        {
            jdone = TRUE;
        }
        
        if (jdone && idone)
            break;

        if (idone==FALSE) i++;
        if (jdone==FALSE) j--;
    }
    
    STSDBG_WR_UNSIGNED(" i = ", i);
  STSDBG_WR_UNSIGNED_LN(" | j = ", j);
    STSDBG_WR_UNSIGNED_LN(" reorder_symbol_rate_count = ", reorder_symbol_rate_count);

    return 0;
}


static unsigned long SRBIN_GetMatchedSR(unsigned long sr_hz)
{
    unsigned long i=0;
//  
//  sr_hz /= 1000;
//  
//  while(i<known_symbol_rate_num)
//  {
//      if (known_symbol_rate_table[i]<=sr_hz)
//          break;
//      
//      i++;    
//  }
//  
//  return known_symbol_rate_table[i] * 1000;
    if (reorder_symbol_rate_current<reorder_symbol_rate_count)
    {
        i = reorder_symbol_rate_table[reorder_symbol_rate_current]*1000;
        reorder_symbol_rate_current++;
    }
    
    return i;
}
#endif

static void SRBIN_NextBin_PreBin()
{
    volatile unsigned char *addr;
    unsigned int end=0, start=0;
    unsigned long delta_sr,delta_tm;
    
    addr = (volatile unsigned char *)0x304E0050;
    start = clock();
    end = start;
    
    if( channel_info.symbol_rate_hz >= 30000000 )
    {
        delta_sr = 2500000;
        delta_tm = 80;
    }
    else if( channel_info.symbol_rate_hz >= 20000000 )
    {
        delta_sr = 2000000;
        delta_tm = 80;
    }
    else if( channel_info.symbol_rate_hz >= 10000000)
    {
        delta_sr = 1500000;
        delta_tm = 100;
    }
    else
    {
        delta_sr = 800000;
        delta_tm = 200;
    }
    
    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect Time = ", delta_tm); 
    
    /*Try to test if demod is locked for 10 times.*/
    while((clock() - start)<delta_tm)
    {
        if ((*addr)&0x02)
        {
                try_next_channel = 0;
                end = clock();
                if (max_dmd_lock_detect_time<(end-start))
                    max_dmd_lock_detect_time = end-start;
                
                //STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect Time (0M) = ", end-start);    
                break;
        }
    }
    
    if (try_next_channel)
    {
        HAMARO_SetSymbolRate(hamaro_nim_list.nim[0],sr_last_known_good_khz*1000);
        while((clock() - start)<delta_tm*2)
        {
            if ((*addr)&0x02)
            {
                    try_next_channel = 0;
                    end = clock();
                    if (max_dmd_lock_detect_time<(end-start))
                        max_dmd_lock_detect_time = end-start;
                        
                    STSDBG_WR_UNSIGNED_LN(" DMD LOCK Detect last know sr = ", sr_last_known_good_khz);   
                    break;
            }  
        }
    }
    
    if (try_next_channel)
    {
        HAMARO_SetSymbolRate(hamaro_nim_list.nim[0],channel_info.symbol_rate_hz-delta_sr);
        while((clock() - start)<delta_tm*3)
        {
            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;