demod_hamaro.c

机顶盒Hamaro解调器驱动。包含自动搜台

        }
        #endif
		
     }
    else
    {    
#endif
    /* perform the read */
    if (( demod_access_method == DEMOD_IIC)
#if (INTERNAL_DEMOD == INTERNAL_COBRA_LIKE)
            || ((demod_access_method == DEMOD_HYBRID) &&
                (reg_addr == 0 ||reg_addr == 0x23 || reg_addr == 0x33 || reg_addr == 0x34 ||
                reg_addr == 0x39 || reg_addr == 0x3a || reg_addr == 0x3b || reg_addr == 0x3c ||
                reg_addr == 0x43 || reg_addr == 0x44))
#endif
	)
    {
        /* get serial bus address from demod handle */
        serial_bus_addr = (unsigned char)(demod_handle & 0x000000FF);

        /* determine DEMOD_A or DEMOD_B register address offset. */
        if ( (demod_handle >> 16) != 0 )
            reg_addr |= 0x80;   /* add 128 to register address. */

       #if (INTERNAL_DEMOD == INTERNAL_COBRA_LIKE)
        if ( demod_access_method == DEMOD_HYBRID )
        {
            CNXT_SET( PLL_PAD_FAST_CTRL_REG, PLL_FAST_CTRL_DEMOD_CONNECT_SEL_MASK,
                    PLL_FAST_CTRL_DEMOD_CONNECT_I2C );
        }
        #endif

        *status = !iicReadIndexedReg( serial_bus_addr, reg_addr, (unsigned char *)&reg_value, demod_iic_bus );

#if (INTERNAL_DEMOD == INTERNAL_COBRA_LIKE)
        if ( demod_access_method == DEMOD_HYBRID )
        {
            CNXT_SET( PLL_PAD_FAST_CTRL_REG, PLL_FAST_CTRL_DEMOD_CONNECT_SEL_MASK,
                    PLL_FAST_CTRL_DEMOD_CONNECT_ASX );
        }
#endif
    }
#if (INTERNAL_DEMOD == INTERNAL_COBRA_LIKE)
    else if ( demod_access_method == DEMOD_REGISTER || demod_access_method == DEMOD_HYBRID )
    {
        reg_value = *(LPREG)INTERNAL_DEMOD_REG_TO_ASX_ADDR(reg_addr);
        *status = 0; /* indicate success */
    }
#endif
    else
    {
        trace_new( TL_ERROR, "Bad demod access method in Hamaro SBRead!\n" );
        *status = 1; /* indicate failure */
        return 0;
    }
#if (HAMARO_INCLUDE_RATTLER || HAMARO_INCLUDE_VIPER)  
    }  	
#endif

    return reg_value;
}
/*******************************************************************************************************/
/* Hamaro_GetSignalStrength() */
/*******************************************************************************************************/
static bool    Hamaro_GetSignalStrength(                 /* function to get Signal Strength value */
unsigned char    *Strength)                       /* AGC accumulator value returned to caller */
{
  #if (INTERNAL_DEMOD == INTERNAL_COBRA_LIKE)
    u_int32 stat;

  unsigned long  ulTemp;
  unsigned long  accum;

  if (Strength != NULL)
  {
    /* set accum, sub-accum (to allow read desired count) */
    ulTemp = 0UL;
    SBWrite(demod_handle[0], 0x3a, ulTemp, &stat );

    /* read the shared accum register */
    accum=SBRead(demod_handle[0], 0x3b, &stat );
    if(stat != 0UL)
        return(False); 

    ulTemp = HAMARO_DRIVER_convert_twos(accum,HAMARO_Register_bitlength(CX2430X_DMDACCUMVAL));
    *Strength = 128 + (HAMARO_AGCACC)ulTemp;
    return(True);
  }
#endif
  return(False);

}  /* HAMARO_GetAGCAcc() */

/*****************************************************************************/
/*  FUNCTION:    xlat_fec_in                                                 */
/*                                                                           */
/*  PARAMETERS:  fec - the FEC rate as defined for multi-instance demod.     */
/*                                                                           */
/*  DESCRIPTION: This function translates an FEC rate from the enumeration   */
/*               used by multi-instance demod to that used by San Diego      */
/*               driver code.                                                */
/*                                                                           */
/*  RETURNS:     The San Diego driver code equivalent FEC rate.              */
/*                                                                           */
/*  CONTEXT:     May be called from interrupt or non-interrupt context.      */
/*                                                                           */
/*****************************************************************************/
static CODERATE xlat_fec_in( NIM_FEC_RATE fec )
{
    switch ( fec )
    {
        case M_RATE_1_2:  return CODERATE_1DIV2;
        case M_RATE_2_3:  return CODERATE_2DIV3;
        case M_RATE_3_4:  return CODERATE_3DIV4;
        case M_RATE_4_5:  return CODERATE_4DIV5;
        case M_RATE_5_6:  return CODERATE_5DIV6;
        case M_RATE_6_7:  return CODERATE_6DIV7;
        case M_RATE_7_8:  return CODERATE_7DIV8;
        default:          return CODERATE_NONE;
    }
}

/*****************************************************************************/
/*  FUNCTION:    xlat_fec_out                                                */
/*                                                                           */
/*  PARAMETERS:  fec - the FEC rate as defined by San Diego driver code.     */
/*                                                                           */
/*  DESCRIPTION: This function translates an FEC rate from the enumeration   */
/*               used by San Diego driver code to that used by the multi-    */
/*               instance demod.                                             */
/*                                                                           */
/*  RETURNS:     The multi-instance demod equivalent FEC rate.               */
/*                                                                           */
/*  CONTEXT:     May be called from interrupt or non-interrupt context.      */
/*                                                                           */
/*****************************************************************************/
NIM_FEC_RATE xlat_fec_out( CODERATE fec )
{
    switch ( fec )
    {
        case CODERATE_1DIV2:  return M_RATE_1_2;
        case CODERATE_2DIV3:  return M_RATE_2_3;
        case CODERATE_3DIV4:  return M_RATE_3_4;
        case CODERATE_4DIV5:  return M_RATE_4_5;
        case CODERATE_5DIV6:  return M_RATE_5_6;
        case CODERATE_6DIV7:  return M_RATE_6_7;
        case CODERATE_7DIV8:  return M_RATE_7_8;
        default:              return M_RATE_NONE;
    }
}

/*****************************************************************************/
/*  FUNCTION:    xlat_spectrum_in                                            */
/*                                                                           */
/*  PARAMETERS:  spectrum - the spectrum specifier as defined for multi-     */
/*               instance demod.                                             */
/*                                                                           */
/*  DESCRIPTION: This function translates a spectrum specifier from the      */
/*               enumeration used by multi-instance demod to that used by    */
/*               San Diego driver code.                                      */
/*                                                                           */
/*  RETURNS:     The San Diego driver code equivalent spectrum specifier.    */
/*                                                                           */
/*  CONTEXT:     May be called from interrupt or non-interrupt context.      */
/*                                                                           */
/*****************************************************************************/
static SPECINV xlat_spectrum_in( NIM_SATELLITE_SPECTRUM spectrum )
{
    switch ( spectrum )
    {
        case SAT_SPECTRUM_NORMAL:    return SPEC_INV_OFF;
        case SAT_SPECTRUM_INVERTED:  return SPEC_INV_ON;
        case SAT_SPECTRUM_AUTO:      return SPEC_INV_ON_BOTH;
        default:                     return SPEC_INV_ON_BOTH;
    }
}

/*****************************************************************************/
/*  FUNCTION:    xlat_diseqc_rxmode                                          */
/*                                                                           */
/*  PARAMETERS:  rxmode - The RX mode to receive DiSEqC message.             */
/*                                                                           */
/*  DESCRIPTION: This function translates an RX mode from the enumeration    */
/*               used by multi-instance demod to that used by San Diego      */
/*               driver code.                                                */
/*                                                                           */
/*  RETURNS:     The San Diego driver code equivalent RX mode.               */
/*                                                                           */
/*  CONTEXT:     May be called from interrupt or non-interrupt context.      */
/*                                                                           */
/*****************************************************************************/
#ifdef INCLUDE_DISEQC2
static RXMODE xlat_diseqc_rxmode( DISEQC_RXMODE rxmode )
{
    switch ( rxmode )
    {
        case DISEQC_RXMODE_INTERROGATION: return RXMODE_INTERROGATION;
        case DISEQC_RXMODE_QUICKREPLY:    return RXMODE_QUICKREPLY;
        case DISEQC_RXMODE_NOREPLY:       return RXMODE_NOREPLY;
        case DISEQC_RXMODE_DEFAULT:       return RXMODE_DEFAULT;
        default:                          return RXMODE_DEFAULT;
    }
}
#endif //#ifdef INCLUDE_DISEQC2
/*****************************************************************************/
/*  FUNCTION:    hamaro_connecting_state                                      */
/*                                                                           */
/*  PARAMETERS:  unit - the unit to process in the CONNECTING state.         */
/*               pending - the mask of currently pending interrupts.         */
/*               old - the previous acquisition state.                       */
/*               new - the new (current) acquisition state.                  */
/*                                                                           */
/*  DESCRIPTION: This function implements the processing required on receipt */
/*               of an interrupt in the CONNECTING state.                    */
/*                                                                           */
/*  RETURNS:     Nothing.                                                    */
/*                                                                           */
/*  CONTEXT:     Will be run in task context.                                */
/*                                                                           */
/*****************************************************************************/
static void hamaro_connecting_state( u_int32 unit, INTEROPTS pending, ACQSTATE old, ACQSTATE new )
{
    int rc;
    DEMOD_CALLBACK_DATA parm;
     CODERATE codeRate;

    trace_new( TL_FUNC, "CONNECTING state processing for unit %d\n", unit );

    /* If we got an acquisition interrupt, and the new acquisition state is
       locked and tracking, then we will transition to the connected state. */
    if ( new == ACQ_LOCKED_AND_TRACKING )
    {
        local_state[unit] = CONNECTED;
          /* Get the code rate */
          API_GetViterbiRate(&NIMs[unit], &codeRate);
          /* Update the local tuning structure with the code rate */
          local_tuning[unit].tune.nim_satellite_tune.fec = xlat_fec_out(codeRate);

        rc = tick_stop( hHamaroTick[unit] );
        if ( rc != RC_OK )
        {
            trace_new( TL_ERROR, "Hamaro can't stop tick timer!\n" );
            error_log( ERROR_WARNING | RC_SDM_SYSERR );
        }

        trace_new( TL_FUNC, "Switching to CONNECTED state for unit %d\n", unit );
        trace_new( TL_VERBOSE, "There were %d acquisition failures\n", DEMOD_CONNECT_COUNTDOWN-acq_failure_countdown[unit] );

        if ( callbacks[unit] )
        {
            parm.parm.type = DEMOD_CONNECTED;
            callbacks[unit]( my_module, unit, DEMOD_CONNECT_STATUS, &parm );
        }

    }

    /* We got an acquisition interrupt, but the new acquisition state is not
       locked and tracking, so count down to determine status. */
    else
    {
        /* If not completely through, reset the interrupt and keep going. */
        if ( acq_failure_countdown[unit] )
        {
            --acq_failure_countdown[unit];
        }
        else
        {
            local_state[unit] = CONT_CONNECTING;

            rc = tick_stop( hHamaroTick[unit] );
            if ( rc != RC_OK )
            {
                trace_new( TL_ERROR, "Hamaro can't stop tick timer!\n" );
                error_log( ERROR_WARNING | RC_SDM_SYSERR );
            }

            if ( callbacks[unit] )
            {
                parm.parm.type = DEMOD_FAILED;
                callbacks[unit]( my_module, unit, DEMOD_CONNECT_STATUS, &parm );
            }
        }
    }