cx24143_fun.c

来自「QPSK Tuner details, for conexant chipset」· C语言 代码 · 共 1,929 行 · 第 1/5 页

  /* (CR6838) clear the esno average buffer */
  if (API_GetChannelEsNo(nim,ESNOMODE_UNDEF,NULL,NULL) == False)  return(False); 

  /* set the clock smoother freq if required (otherwise, clksmooth freq will be set at API_SetOutputOptions() ) */
  if (nim->mpeg_out.ClkSmoothSel == DDS_LEGACY_SMOOTHING)
  {
    if (DRIVER_SetSmoothClock(nim,nim->mpeg_out.ClkSmoothSel,True) == False)  return(False);
  }
#ifdef CAMARIC_FEATURES
  else if (nim->mpeg_out.ClkSmoothSel == PLL_ADVANCED_SMOOTHING)
  {
    if (DRIVER_SetSmoothClock(nim,nim->mpeg_out.ClkSmoothSel,True) == False)  return(False);
  }
#endif /* #ifdef CAMARIC_FEATURES */

  return(True);

}  /* API_ChangeChannel() */


/*******************************************************************************************************/
/* API_Monitor() */
/*******************************************************************************************************/
BOOL      API_Monitor(                 /* Monitors the demod after a successful channel change operation */
NIM       *nim,                        /* pointer to NIM */
ACQSTATE  *state,                      /* storage for returned acqusition state of demod */
LOCKIND   *lockinds)                   /* storage for returned demod lock indicators */
{
  ULONG  locked;
   
  /* test for valid nim */
  if (DRIVER_ValidateNim(nim) == False)  return(False);

  if (state == NULL || lockinds == NULL)  
  {
    DRIVER_SetError(nim,API_BAD_PARM);
    return(False);
  }
  /* if an i/o error occurred during last i/o attempt, do not allow a Monitor deadlock condition to occur */
  if (nim->iostatus != 0UL)  return(False);

  /* retrieve  lock indicators */
  if (API_GetLockIndicators(nim,lockinds) == False)  return(False);

  /* give some time to the acq engine */
  if (API_AcqContinue(nim,state) == False)  return(False);

  /* perform SW assist acq when NOT locked*/
  if (*state == ACQ_SEARCHING || *state == ACQ_FADE)
  {
    /* perform SW assist as required */
    if (DRIVER_SWAssistAcq(nim) == False)
    {
      DRIVER_SetError(nim,API_BAD_SWA);
      return(False);
    }
    /* re-read the acq state after we re-gained lock */
    if (API_AcqContinue(nim,state) == False)  return(False);
  }

  /* retrieve  lock indicators */
  if (API_GetLockIndicators(nim,lockinds) == False)  return(False);

  /* perform performance changes once */
  if (lockinds->reedsolomon == TRUE)
  {
	/* We are locked. */
    if (nim->prevstatecounter == 0)
	{
      if (DRIVER_SetSoftDecisionThreshold(nim) == False)
	  {
        return (False);
	  }

      nim->prevstatecounter = 1;
	}
  }
  else
  {
	  /* we are NOT locked, set the state as such. */
      nim->prevstatecounter = 0;
  }
  
  /* (CR 6243) */
  if(DRIVER_SWAssistTuner(nim) == False)
  {
    DRIVER_SetError(nim,API_BAD_SWA);
    return(False);
  }

  /* (CR 9436) set the clksmoothdiv only if required.  (after Chan.Change or after lock/unlock transition) */
  if (nim->CLKSMDIV_flag == CLKSMOOTHDIV_UPDATE)
  {
    /* test for first API_Monitor after change-channel.  If so, test lock */
    if (RegisterRead(nim,CX24130_ACQFULLSYNC,&locked) == False)  return(False);

    if (locked == 0x01UL)
    {
      /* Demod is locked.  This is first API_Monitor after Chan.Change, so set ClkSmootherDiv rate */
      /* when the clock smoother is turned on */
      if (nim->mpeg_out.ClkSmoothSel == DDS_LEGACY_SMOOTHING   /* CR9436 */
#ifdef CAMARIC_FEATURES
          || nim->mpeg_out.ClkSmoothSel == PLL_ADVANCED_SMOOTHING)
#else
         )
#endif
      {
        ULONG  nominal;
        ULONG  curr;
						 
        /* Read the Current Viterbi code rate */
        if (RegisterRead(nim,CX24130_ACQVITCURRCR,&curr) != True)  return(False);

        /* Read the nominal Viterbi code rate */
        if (RegisterRead(nim,CX24130_ACQVITCRNOM,&nominal) != True)  return(False);

        /* CR9436: - No need to set ClkSmoothFreqDiv if code rates are equal */
        if (curr != nominal)
        {
		  if (DRIVER_SetSmoothClock(nim,nim->mpeg_out.ClkSmoothSel,False) == False)  return(False);
        }  
		/* cause API_Monitor() to not adjust clk smooth div until next chan.change */
        nim->CLKSMDIV_flag = CLKSMOOTHDIV_PASS;
	  }
    }
  }

  return(True);

}  /* API_Monitor() */


/*******************************************************************************************************/
/* API_SetOutputOptions() */
/*******************************************************************************************************/
BOOL      API_SetOutputOptions(        /* Function to set the demod MPEG output pins */
NIM       *nim,                        /* pointer to nim */
MPEG_OUT  *mpeg_out)                   /* mpeg settings struct */
{
  ULONG  ulRegVal;

  /* validate nim and mpeg storage */
  if (DRIVER_ValidateNim(nim) == False)  return(False);

  if (mpeg_out == NULL)  DRIVER_SetError(nim,API_BADPTR);
  else
  {
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    /* verify/set the output mode */
    switch(mpeg_out->OutputMode)
    {
      case  PARALLEL_OUT:
      case  SERIAL_OUT:
      {
        /* set l to 0 if par, 1 if serial, bail on error */
        ulRegVal = (ULONG)((mpeg_out->OutputMode) == PARALLEL_OUT ? BIT_ZERO : BIT_ONE);
        if (RegisterWrite(nim,CX24130_MPGDATAWIDTH,ulRegVal) == False)  return(False);
        break;
      }
      case  OUTMODE_UNDEF:
      default:
      {
        /* passed parameter was invalid, flag and bail */
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->ClkOutEdge)
    {
      case  CLKOUT_SETUP1_HOLD7:
      case  CLKOUT_SETUP3_HOLD5:
      case  CLKOUT_SETUP5_HOLD3:
      case  CLKOUT_SETUP7_HOLD1:
      {
        if (mpeg_out->OutputMode == PARALLEL_OUT)  
        {
          ulRegVal = (ULONG)(mpeg_out->ClkOutEdge&0x0fUL);
          if (RegisterWrite(nim,CX24130_MPGCLKPOS,ulRegVal) == False)  return(False);
          break;
        }
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
      case  CLKOUT_DATALR_DATACR:
      case  CLKOUT_DATALR_DATACF:
      case  CLKOUT_DATALF_DATACR:
      case  CLKOUT_DATALF_DATACF:
      {
        /* serial out */
        if (mpeg_out->OutputMode == SERIAL_OUT)  
        {
          ulRegVal = (ULONG)(mpeg_out->ClkOutEdge&0x0fUL);
          if (RegisterWrite(nim,CX24130_MPGCLKPOS,ulRegVal) == False)  return(False);
          break;
        }
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
      case  CLKOUT_RISING:
      case  CLKOUT_FALLING:
      case  CLKOUT_ENDEF:
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->ClkParityMode)
    {
      case  CLK_CONTINUOUS:
      case  CLK_GAPPED:
      {
        ulRegVal = (ULONG)(mpeg_out->ClkParityMode == CLK_GAPPED ? 1 : 0);
        if (RegisterWrite(nim,CX24130_MPGGAPCLK,ulRegVal) == False)  return(False);
        break;
      }
      case  CLK_PARITY_UNDEF:
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->HoldTime)
    {
      case  ZERO_HOLD_TIME:
      case  SMALL_HOLD_TIME:
      case  MEDIUM_HOLD_TIME:
      case  LARGE_HOLD_TIME:
      {
        switch(mpeg_out->HoldTime)
        {
          case  ZERO_HOLD_TIME:
          case  SMALL_HOLD_TIME:
          {
            ulRegVal = 0x02UL;
            break;
          }
          case  MEDIUM_HOLD_TIME:
          {
            ulRegVal = 0x00UL;
            break;
          }
          case  LARGE_HOLD_TIME:
          {
            ulRegVal = 0x01UL;
            break;
          }
          default:
          {
            break;
          }
        }  /* switch(... */

        /* write the hold-time registers */
        if (RegisterWrite(nim,CX24130_MPGCLKHOLD,ulRegVal) == False)  return(False);
        break;
      }
      case  CLK_HOLD_UNDEF:
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->StartSignalPolarity)
    {
      case  ACTIVE_LOW:
      case  ACTIVE_HIGH:
      {
        ulRegVal = (mpeg_out->StartSignalPolarity == ACTIVE_HIGH) ? 0x01UL : 0x00UL;
        if (RegisterWrite(nim,CX24130_MPGSTARTPOL,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->StartSignalWidth)
    {
      case  BIT_WIDE:
      case  BYTE_WIDE:
      {
        ulRegVal = (mpeg_out->StartSignalWidth == BIT_WIDE) ? 0x01UL : 0x00UL;
        if (RegisterWrite(nim,CX24130_MPGSTARTMODE,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->ValidSignalPolarity)
    {
      case  ACTIVE_LOW:
      case  ACTIVE_HIGH:
      {
        ulRegVal = (mpeg_out->ValidSignalPolarity == ACTIVE_HIGH) ? 0x00UL : 0x01UL;
        if (RegisterWrite(nim,CX24130_MPGVALIDPOL,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */

    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->ValidSignalActiveMode)
    {
      case  ENTIRE_PACKET:
      case  FIRST_BYTE:
      {
        ulRegVal = (mpeg_out->ValidSignalActiveMode == FIRST_BYTE) ? 0x01UL : 0x00UL;
        if (RegisterWrite(nim,CX24130_MPGVALIDMODE,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->FailSignalPolarity)
    {
      case  ACTIVE_LOW:
      case  ACTIVE_HIGH:
      {
        ulRegVal = (mpeg_out->FailSignalPolarity == ACTIVE_HIGH) ? 0x00UL : 0x01UL;
        if (RegisterWrite(nim,CX24130_MPGFAILPOL,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->FailSignalActiveMode)
    {
      case  ENTIRE_PACKET:
      case  FIRST_BYTE:
      {
        ulRegVal = (mpeg_out->FailSignalActiveMode == FIRST_BYTE) ? 0x01UL : 0x00UL;
        if (RegisterWrite(nim,CX24130_MPGFAILMODE,ulRegVal) == False)  return(False);
        break;
      }
      default:
      {
        DRIVER_SetError(nim,API_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    switch(mpeg_out->SyncPunctMode)
    {
      case  SYNC_WORD_PUNCTURED: