hamaro_api.c

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

      /* translate Cobra raw values to application-usable */
      switch (temp_modtype)
      {
         /* DVB */
         case  0x00:
         {
            nim->tspec = HAMARO_SPEC_DVB;
            break;
         }
         default:
         {
            /* hardware returned an invalid transspec value */
            HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_RTNVAL);
            return(False);
         }
      }  /* switch(... */
   }  /* if (nim->tspec == HAMARO_SPEC_UNDEF) */
   
   *transpec = nim->tspec;

   return(True);

}  /* HAMARO_GetTransportSpec() */


static BOOL 
HAMARO_SetTunerBWAndGain(HAMARO_NIM *nim, HAMARO_SYMBRATE  symbolrate)
{
	unsigned long  requestedLNB;
	unsigned long  bandwidth;
	long		   sigmadelta;

    requestedLNB = HAMARO_DRIVER_GetRequestedSearchRangeLimit(nim);
    requestedLNB /= 1000UL;
    if (requestedLNB == 0UL)  requestedLNB = 1UL;

	if (nim->shadowed_tuner_lnboffset == requestedLNB && nim->shadowed_tuner_symbrate == symbolrate)
	{
		return (True);
	}
	else
	{
		nim->shadowed_tuner_lnboffset = requestedLNB; 
		nim->shadowed_tuner_symbrate  = symbolrate;
	}

	bandwidth = ((symbolrate * 675UL) / 1000UL) + requestedLNB; 

#if HAMARO_INCLUDE_BANDWIDTHADJ
    nim->anti_alias_bandwidth = bandwidth;
#endif /* HAMARO_INCLUDE_BANDWIDTHADJ */

	if (HAMARO_SetTunerBW(nim, bandwidth, &sigmadelta) == False)
	{
		return (False);
	}

    if (HAMARO_TUNER_SetGainSettings(nim,symbolrate) == False)  return(False);

	return (True);
}

/*******************************************************************************************************/
/* HAMARO_SetSymbolRate() */
/*******************************************************************************************************/
BOOL      HAMARO_SetSymbolRate(           /* function to set the demod's symbol rate */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_SYMBRATE  symbolrate)                  /* symbol rate (in Ksps) */
{
  long   temp_symbolrate;

  unsigned long  ulRegVal;
  unsigned long  samplerate;

  HAMARO_SYMBRATE  low_test;
  HAMARO_SYMBRATE  high_test;

  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  low_test = HAMARO_SYM_RATE_LOW;
  high_test = HAMARO_SYM_RATE_HIGH;

  /* set-up default values only for Hamaro */
  low_test = HAMARO_SYM_RATE_LOW_CAM;
  high_test = HAMARO_SYM_RATE_HIGH_CAM;

  /* range test symbolrate */
  if (symbolrate >= (unsigned long)low_test && symbolrate <= (unsigned long)high_test)
  {
	/* CR9879, always reset LNB search range to take cases where
	 * HAMARO_NIM_DEFAULT_LNB is greater than the front end LNB offset limit. */
    nim->symbol_rate_ideal = symbolrate;

    /* read the sample rate */
    if (HAMARO_GetSampleFrequency(nim,&samplerate) == False)  return(False);

    /* (CR 8797 set the pdmfout and sample rate registers) */
    nim->pdmfout = HAMARO_DRIVER_Set_Pdmfout(nim,(nim->symbol_rate_ideal*(1UL*HAMARO_M)),samplerate);

    /* compute the symbol rate */
    temp_symbolrate = HAMARO_DRIVER_symbolrate_in(symbolrate,samplerate);
    nim->symbol_rate = (unsigned long)symbolrate;

    /* write computed value to demod */
    ulRegVal = (unsigned long)temp_symbolrate;
    if (HAMARO_RegisterWrite(nim,CX2430X_SYSSYMBOLRATE,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

    /* when the symbol rate changes, the number of bins searched will be modified to reflect */
    /* the default min lnb search range required per CR #5703 */
    /* nim->lnboffset = HAMARO_NIM_DEFAULT_LNB; */
    
    /* (REMOVED per CR 6748/6747) ... retrieve  the search-range-limit, convert actual to khz */
    /* if (HAMARO_GetSearchRangeLimit(nim,&actual) == False)  return(False); */
    /* actual /= 1000UL; */
        
    /* optimize CTL Tracking Bandwidth based on symbol rate */
    if(HAMARO_DRIVER_SetCTLTrackBW(nim,symbolrate) == False)  return(False);

	/* CR9879, always reset LNB search range to take cases where
	 * HAMARO_NIM_DEFAULT_LNB is greater than the front end LNB offset limit. */

    /* (CR 8514) Reset the LNB Search Range (bins) if required. */
    if(nim->symbol_rate_ideal>10000UL)
    {
        nim->lnboffset =  5*HAMARO_MM;
    }
    else
    {
        nim->lnboffset =  3*HAMARO_MM;
    }
    
    if (HAMARO_SetSearchRangeLimit(nim,nim->lnboffset,&ulRegVal) == False)  return(False);

    return(True);
  }

  HAMARO_DRIVER_SET_ERROR(nim,HAMARO_PARM_RANGE);
  return(False);

}  /* HAMARO_SetSymbolRate() */


/*******************************************************************************************************/
/* HAMARO_GetSymbolRate() */
/*******************************************************************************************************/
BOOL      HAMARO_GetSymbolRate(           /* function to return demod's current symbol rate setting */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_SYMBRATE  *symbolrate)                 /* returned current symbol rate setting */
{
  unsigned long  temp_symbolrate;
  unsigned long  samplerate;

  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* read the sample rate */
  if (HAMARO_GetSampleFrequency(nim,&samplerate) == False)  return(False);

  /* read the symbolrate teh demod is set to */
  if (HAMARO_RegisterRead(nim,CX2430X_SYSSYMBOLRATE,symbolrate, HAMARO_DEMOD_I2C_IO) == False)  return(False);

   /* compute the symbolrate to be returned to the caller */
  temp_symbolrate = (unsigned long)HAMARO_DRIVER_symbolrate_out(*symbolrate,samplerate);
  nim->symbol_rate = temp_symbolrate;
  *symbolrate = temp_symbolrate;

  return(True);

}  /* HAMARO_GetSymbolRate() */


/*******************************************************************************************************/
/* HAMARO_GetMinSymbolRate() */
/*******************************************************************************************************/
BOOL           HAMARO_GetMinSymbolRate(   /* function to return demod's minimum symbol rate (in Khz)*/
HAMARO_NIM            *nim,                   /* pointer to nim */
unsigned long  *minsymbolrate)         /* returned min. symbol rate (in Khz) */
{
  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  *minsymbolrate = HAMARO_SYM_RATE_LOW_CAM*1UL;
  return(True);
}  /* HAMARO_GetMinSymbolRate() */


/*******************************************************************************************************/
/* HAMARO_GetMaxSymbolRate() */
/*******************************************************************************************************/
BOOL           HAMARO_GetMaxSymbolRate(   /* function to return the demod's max symbol rate (in Khz) */
HAMARO_NIM            *nim,                   /* pointer to nim */
unsigned long  *maxsymbolrate)         /* returned max. symbol rate (in Khz) */
{
  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* validate arguments */
  if (maxsymbolrate == NULL)
  {
     HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
     return(False);
  }

  *maxsymbolrate = HAMARO_SYM_RATE_HIGH_CAM*1UL;
  return(True);
}  /* HAMARO_GetMaxSymbolRate() */


/*******************************************************************************************************/
/* HAMARO_SetViterbiRate() */
/*******************************************************************************************************/
BOOL      HAMARO_SetViterbiRate(          /* function to set the demod viterbi rate */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_CODERATE  coderate)                    /* viterbi rate setting */
{
  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  return(HAMARO_DRIVER_SetViterbiRate(nim,coderate));

}  /* HAMARO_SetViterbiRate() */


/*******************************************************************************************************/
/* HAMARO_GetViterbiRate() */
/*******************************************************************************************************/
BOOL      HAMARO_GetViterbiRate(          /* function to read the demod's current viterbi rate setting */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_CODERATE  *coderate)                   /* returned current viterbi code rate setting */
{
  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  return(HAMARO_DRIVER_GetViterbiRate(nim,coderate));

}  /* HAMARO_GetViterbiRate() */


/*******************************************************************************************************/
/* HAMARO_SetSpectralInversion() */
/*******************************************************************************************************/
BOOL     HAMARO_SetSpectralInversion(     /* function to set the demod's spectral inversion setting */
HAMARO_NIM      *nim,                         /* pointer to nim */
HAMARO_SPECINV  specinv)                      /* spectral inv. setting */
{
  unsigned long  ulRegVal;

  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  if(nim->tuner_type == HAMARO_CX24108)
  {
	  switch(specinv)
	  {
		case HAMARO_SPEC_INV_OFF:
			specinv = HAMARO_SPEC_INV_ON;
			break;
		case HAMARO_SPEC_INV_ON:
			specinv = HAMARO_SPEC_INV_OFF;
			break;
		case HAMARO_SPEC_INV_ON_BOTH:
			specinv = HAMARO_SPEC_INV_OFF_BOTH;
			break;
		case HAMARO_SPEC_INV_OFF_BOTH:
			specinv = HAMARO_SPEC_INV_ON_BOTH;
			break;
		case HAMARO_SPEC_INV_UNDEF:
			break;
	  }
  }
		   
  switch(specinv)
  {
    case  HAMARO_SPEC_INV_OFF:
    {
      /* write zero to ACQVitSINom, one to ACQSISearchDis */
      ulRegVal = 0UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITSINOM,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      ulRegVal = 1UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQSISEARCHDIS,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      break;
    }
    case  HAMARO_SPEC_INV_ON:
    {
      /* write one to ACQVitSINom, one to ACQSISearchDis */
      ulRegVal = 1UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITSINOM,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      ulRegVal = 1UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQSISEARCHDIS,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      break;
    }
    case  HAMARO_SPEC_INV_ON_BOTH:
    {
      /* write one to AcqVitSINom, zero to ACQSISearchDis */
      ulRegVal = 1UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITSINOM,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      ulRegVal = 0UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQSISEARCHDIS,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      break;
    }
    case  HAMARO_SPEC_INV_OFF_BOTH:
    {
      /* write one to AcqVitSINom, zero to ACQSISearchDis */
      ulRegVal = 0UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQVITSINOM,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      ulRegVal = 0UL;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQSISEARCHDIS,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      break;
    }
    default:
    {
      /* inform caller of error */
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
      return(False);
    }
  }  /* switch(... */
  
  return(True);

}  /* HAMARO_SetSpectralInversion() */


/*******************************************************************************************************/
/* HAMARO_GetSpectralInversion() */
/*******************************************************************************************************/
BOOL      HAMARO_GetSpectralInversion(    /* function to read the demod's spectral inversion setting */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_SPECINV   *specinv)                    /* returned spectral inv. settings */
{
  unsigned long   spec_curr;

  /* test HAMARO_NIM for validity */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* read current viterbi spec inv */
  if (HAMARO_RegisterRead(nim,CX2430X_ACQVITCURRSI,&spec_curr, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  /* report spec inv setting */  
  if (spec_curr == 0x01UL)  *specinv = HAMARO_SPEC_INV_ON;
  else  *specinv = HAMARO_SPEC_INV_OFF;  
  
  if(nim->tuner_type == HAMARO_CX24108)
  {
	  switch(*specinv)
	  {
		case HAMARO_SPEC_INV_OFF:
			*specinv = HAMARO_SPEC_INV_ON;
			break;
		case HAMARO_SPEC_INV_ON:
			*specinv = HAMARO_SPEC_INV_OFF;
			break;
		default:
			break;
	  }
  }

  return(True);

}  /* HAMARO_GetSpectralInversion() */


/*******************************************************************************************************/
/* HAMARO_AcqBegin() */
/*******************************************************************************************************/
BOOL  HAMARO_AcqBegin(                    /* function to start/restart d