hamaro_drv.c

QPSK Tuner details, for conexant chipset.

            case  HAMARO_SPEC_DVB:
            {
              /* search possible coderates for transpec, then OR into vitsetting */
              for (j = 0 ; dvb_cr_list[j] != HAMARO_CODERATE_NONE ; j++)
              {
                /* if coderate (cr) matches i index, then coderates match */
                if (dvb_cr_equate[j] == i)
                {
                  vitlist->viterbi_list[vitlist->vcnt] = dvb_cr_list[j];
                  vitlist->vcnt++;
                  break;
                }
              }
              break;
            }
            default:
            {
              HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
              return(False);
              break;
            }
          }  /* switch(... */
        }
      }  /* for(... */

      /* vitlist has been built into struct pointer passed by caller */
      return(True);
    }
  }

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

}  /* DRIVER_AcqGetViterbiSearchList() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetViterbiRate() */
/*******************************************************************************************************/
BOOL      HAMARO_DRIVER_SetViterbiRate(       /* function to set the demod's primary viterbi rate  */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_CODERATE  coderate)                    /* viterbi coderate */
{
  int    i;
  
  unsigned long  ulRegVal;

  HAMARO_TRANSPEC  transpec;

  if (HAMARO_GetTransportSpec(nim,&transpec) == True)
  {
    switch(coderate)
    {
      case  HAMARO_CODERATE_1DIV2:
      case  HAMARO_CODERATE_2DIV3:
      case  HAMARO_CODERATE_3DIV4:
      case  HAMARO_CODERATE_4DIV5:
      case  HAMARO_CODERATE_5DIV6:
      case  HAMARO_CODERATE_6DIV7:
      case  HAMARO_CODERATE_7DIV8:
      {
        switch(transpec)
        {
          case  HAMARO_SPEC_DVB:
          {

            /* find the code rate desired, plug into demod */
            for (i = 0 ; dvb_cr_list[i] != HAMARO_CODERATE_NONE ; i++)
            {
              if (dvb_cr_list[i] == coderate)
              {
                /* set Viterbi lock threshold optimized for the coderate */
                HAMARO_DRIVER_SetViterbiLockThresh(nim,coderate);

                ulRegVal = (unsigned long)dvb_cr_equate[i];
                return(HAMARO_RegisterWrite(nim,CX2430X_ACQVITCRNOM,ulRegVal, HAMARO_DEMOD_I2C_IO));
              }
            }
            HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
            return(False);
            break;
          }
          case  HAMARO_SPEC_UNDEF:
          default:
          {
            HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
            return(False);
            break;
          }
        }  /* switch(... */
        break;
      }
      case  HAMARO_CODERATE_NONE:
      default:
      {
        HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
        return(False);
        break;
      }
    }  /* switch(... */
  }
  
  return(False);

}  /* HAMARO_DRIVER_SetViterbiRate() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_GetViterbiRate() */
/*******************************************************************************************************/
BOOL      HAMARO_DRIVER_GetViterbiRate(       /* function to set the demod's primary viterbi rate  */
HAMARO_NIM       *nim,                        /* pointer to nim */
HAMARO_CODERATE  *coderate)                   /* viterbi coderate */
{
  int   i;

  unsigned long  vitrate;
  unsigned long  locked;

  HAMARO_TRANSPEC  transpec;

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

  /* read the trans spec */
  if (HAMARO_GetTransportSpec(nim,&transpec) == True)
  {
    /* read the current lock status. If locked, return the current code rate */
    if (HAMARO_RegisterRead(nim,CX2430X_ACQFULLSYNC,&locked, HAMARO_DEMOD_I2C_IO) == False)  return(False);
    if (locked == 0x01UL)
    {
      /* (CR6839) read the current viterbi rate */
      if (HAMARO_RegisterRead(nim,CX2430X_ACQVITCURRCR,&vitrate, HAMARO_DEMOD_I2C_IO) != True)  return(False);
    }
    else
    {
      /* not locked, so read the last code rate programmed via the viterbi nom register */
      if (HAMARO_RegisterRead(nim,CX2430X_ACQVITCRNOM,&vitrate, HAMARO_DEMOD_I2C_IO) != True)  return(False);
    }

    /* return the viterbi rate to the caller */
    switch(transpec)
    {
      case  HAMARO_SPEC_DVB:
      {
        for (i = 0 ; dvb_cr_list[i] != HAMARO_CODERATE_NONE ; i++)
        {
          if ((int)vitrate == dvb_cr_equate[i])  
          {
            *coderate = dvb_cr_list[i];
            return(True);
          }
        }
        break;
      }

      default:
      {
        /* demod is in an invalid mode */
        HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
        break;
      }
    }  /* switch(... */
    
  }
  
  return(False);

}  /* HAMARO_DRIVER_GetViterbiRate() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetSmoothClock() */
/*******************************************************************************************************/
BOOL           HAMARO_DRIVER_SetSmoothClock(  /* funct to set the clock smoother MPEG register */
HAMARO_NIM            *nim,                   /* pointer to nim */
HAMARO_CLOCKSMOOTHSEL cs,                     /* clk smoother setting: CLK_SMOOTHER_ON, CLK_SMOOTHER_OFF */
BOOL           fromCC)                 /* TRUE if this funct has been called from HAMARO_ChangeChannel() */
{
  unsigned long  locked;
  unsigned long  smoothclkdiv;
  unsigned long  pllmult;

  unsigned long  symbolrate;
  unsigned long  datalen = 0UL;
  unsigned long  cwlen;

  unsigned long  cr = 0UL;
  unsigned long  crdiv = 0UL;
  unsigned long  divno;
  
  unsigned long  rsparitydis;
  unsigned long  syncpunctmode;

  HAMARO_CODERATE  coderate = HAMARO_CODERATE_NONE;
  HAMARO_TRANSPEC  transpec;

  HAMARO_BCDNO     bcdno;

  if (HAMARO_GetTransportSpec(nim,&transpec) == False)  return(False);

  pllmult = (unsigned long)nim->ucPLLMult_shadow;
  if (HAMARO_GetSymbolRate(nim,&symbolrate) == False)  return(False);

  /* (CR 7957) if locked to a signal, use that Coderate within clk.smoother.div calculation.  else, use highest Coderate */
  if (HAMARO_RegisterRead(nim,CX2430X_ACQFULLSYNC,&locked, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  if (locked == 0x01UL)
  {
    /* demod is locked, so use the locked coderate in the clkcmoother calc */
    if (HAMARO_GetViterbiRate(nim,&coderate) == False)  return(False);
    nim->CLKSMDIV_CR = coderate;
  }
  else
  {
    unsigned int  vrates;

    /* nim has not locked with newest coderate yet, so flag this */
    if (fromCC == True || nim->CLKSMDIV_CR == HAMARO_CODERATE_NONE)
    {
      /* demod is NOT locked, so use the highest coderate within the clksmoother calc */
      if (HAMARO_AcqGetViterbiCodeRates(nim,&vrates) == False)  return(False);
      coderate = HAMARO_CODERATE_NONE;
    }
    else
    {
      /* cause no search rates to be found, use last-locked coderate */
      vrates = 0;
      coderate = nim->CLKSMDIV_CR;
    }

    if ((vrates&HAMARO_CODERATE_7DIV8) !=0)  coderate = HAMARO_CODERATE_7DIV8;
    else
    {
      if ((vrates&HAMARO_CODERATE_6DIV7) !=0)  coderate = HAMARO_CODERATE_6DIV7;
      else
      {
        if ((vrates&HAMARO_CODERATE_5DIV6) !=0)  coderate = HAMARO_CODERATE_5DIV6;
        else
        {
          if ((vrates&HAMARO_CODERATE_4DIV5) !=0)  coderate = HAMARO_CODERATE_4DIV5;
          else
          {
            if ((vrates&HAMARO_CODERATE_3DIV4) !=0)  coderate = HAMARO_CODERATE_3DIV4;
            else
            {
              if ((vrates&HAMARO_CODERATE_2DIV3) !=0)  coderate = HAMARO_CODERATE_2DIV3;
              else
              {
                if ((vrates&HAMARO_CODERATE_1DIV2) !=0)  coderate = HAMARO_CODERATE_1DIV2;
              }
            }
          }
        }
      }
    }
  }

  switch(coderate)
  {
    case  HAMARO_CODERATE_1DIV2:
    {
      cr = 1;
      crdiv = 2;
      break;
    }
    case  HAMARO_CODERATE_2DIV3:
    {
      cr = 2;
      crdiv = 3;
      break;
    }
    default:  /* default coderate for sync punct */
    case  HAMARO_CODERATE_3DIV4:
    {
      cr = 3;
      crdiv = 4;
      break;
    }
    case  HAMARO_CODERATE_4DIV5:
    {
      cr = 4;
      crdiv = 5;
      break;
    }
    case  HAMARO_CODERATE_5DIV6:
    {
      cr = 5;
      crdiv = 6;
      break;
    }
    case  HAMARO_CODERATE_6DIV7:
    {
      cr = 6;
      crdiv = 7;
      break;
    }
    case  HAMARO_CODERATE_7DIV8:
    {
      cr = 7;
      crdiv = 8;
      break;
    }
  }  /* switch(... */

  if (HAMARO_RegisterRead(nim,CX2430X_MPGGAPCLK,&rsparitydis, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  if (HAMARO_RegisterRead(nim,CX2430X_MPGSYNCPUNC,&syncpunctmode, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  switch (transpec)
  {
    default:
    case  HAMARO_SPEC_DVB:
    {
      cwlen = 204UL;
      if (rsparitydis == 0UL && syncpunctmode == 0UL)  datalen = 204UL;
      else  if (rsparitydis == 1UL && syncpunctmode == 0UL)  datalen = 188UL;
      else  if (rsparitydis == 0UL && syncpunctmode == 1UL)  datalen = 203UL;
      else  if (rsparitydis == 1UL && syncpunctmode == 1UL)  datalen = 187UL;
      else  HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
      break;
    }
  }  /* switch(... */

  HAMARO_BCD_set(&bcdno,symbolrate);
  HAMARO_BCD_mult(&bcdno,(4UL * cr * datalen));
  HAMARO_BCD_div(&bcdno,crdiv);
  HAMARO_BCD_div(&bcdno,cwlen);
  divno = HAMARO_BCD_out(&bcdno);

  /* trap div by zero errors */
  if (divno == 0)
  {
	  return (False);
  }
  smoothclkdiv = (int)(nim->crystal_freq * pllmult) / divno;

  /* write the clk smoother freq divider to hw */
  if (HAMARO_RegisterWriteClkSmoothDiv(nim, smoothclkdiv) == False)
  {
     return (False);
  }