hamaro_drv.c

QPSK Tuner details, for conexant chipset.

/*******************************************************************************************************/
/* HAMARO_DRIVER_symbolrate_in() */
/*******************************************************************************************************/
long           HAMARO_DRIVER_symbolrate_in(   /* function to perform common symbol rate computation */
unsigned long  symbolrate,             /* symbol rate (in) */
unsigned long  sampleratekhz)          /* sample rate in hz (in) */
{
  static HAMARO_BCDNO  bcd;
  unsigned long  computed_symbolrate;
  
  /* compute symbolrate programmed to the demod: (symbolrate * 2^23) / rounded(samplerate/1000) */
  HAMARO_BCD_set(&bcd,(symbolrate*1000UL)+500UL);
  HAMARO_BCD_mult(&bcd,(long)(0x01L<<23L));
  HAMARO_BCD_div(&bcd,(sampleratekhz));

  /* symbol rate  */
  computed_symbolrate = HAMARO_BCD_out(&bcd);

  return((long)computed_symbolrate);

}  /* HAMARO_DRIVER_symbolrate_in() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_symbolrate_out() */
/*******************************************************************************************************/
long           HAMARO_DRIVER_symbolrate_out(  /* function to reverse symbolrate_in() function */
unsigned long  symbolrate,             /* symbol rate (in) */
unsigned long  sampleratekhz)          /* sample rate (in) */
{
  static HAMARO_BCDNO  bcd;
  unsigned long  computed_symbolrate = 0UL;

  HAMARO_BCD_set(&bcd,(long)symbolrate);
  HAMARO_BCD_mult(&bcd,100000L);
  HAMARO_BCD_div(&bcd,(0x01L<<23L));
  HAMARO_BCD_mult(&bcd,sampleratekhz);
  HAMARO_BCD_div(&bcd,100000L);

  computed_symbolrate = HAMARO_BCD_out(&bcd);

  return((long)computed_symbolrate);

}  /* HAMARO_DRIVER_symbolrate_out() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_compute_demod_pll_mult() */
/*******************************************************************************************************/
unsigned long  HAMARO_DRIVER_compute_demod_pll_mult(  /* function to compute pll freq. */
HAMARO_NIM            *nim,                           /* pointer to nim */
unsigned long  Fs,                             /* sample frequency */
unsigned long  Fc)                             /* crystal frequency */
{
	unsigned long   pll_mult;
	unsigned short  remainder;

	if (Fs == 0UL || Fc == 0UL)
	{
		/* don't pass any div by zero possibilities */
		if (nim != NULL)  
		{
			HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_DIV);
		}
		return(0UL);
	}

	/* compute pll_mult = (Fs * 6L) / Fc */
    /* make sure the result has the one extra digit from the fraction */
	pll_mult = ((Fs * 6UL) + 5UL) / (Fc/10); /* CR 9760 */

	remainder = (unsigned short)(pll_mult % 10);

	pll_mult = pll_mult/10; /* loose the extra digit */

	if (remainder > 5)
	{
		/* round the pll multiplier value */
		pll_mult++;
	}			   
	return(pll_mult);

}  /* HAMARO_DRIVER_compute_demod_pll_mult() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_compute_fs() */
/*******************************************************************************************************/
unsigned long  HAMARO_DRIVER_compute_fs(      /* function to compute the sample frequency */
unsigned long  pllmult,                /* demod pll multiplier value */
unsigned long  Fc)                     /* crystal frequency */
{
  unsigned long   rtn;

  /* compute Fs = (Fc * pllmult) / 6 ; -> rounded -> (Fc * pllmult + 5) / 60 */
  rtn = ((Fc * pllmult)+5UL)/6UL;
  
  return(rtn);

}  /* HAMARO_DRIVER_compute_fs() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetPNSequence() */
/*******************************************************************************************************/
BOOL     HAMARO_DRIVER_SetPNSequence(         /* function to set the state of the PN machine */
HAMARO_NIM      *nim,                         /* pointer to nim */
BOOL     pnflag)                       /* True=on, False=off */
{
  unsigned long  ulRegVal;
  BOOL   rtn = True;

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  switch(pnflag)
  {
    case  True:
    case  False:
    {
      ulRegVal = (pnflag == True ? 0x01UL : 0x00UL);
      if (HAMARO_RegisterWrite(nim,CX2430X_BERERRORSEL,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      break;
    }
    default:
    {
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
      rtn = False;
      break;
    }
  }  /* switch(... */

  return(rtn);

}  /* HAMARO_DRIVER_SetPNSequence() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_GetPNSequence() */
/*******************************************************************************************************/
BOOL     HAMARO_DRIVER_GetPNSequence(         /* function to read current state of PN */
HAMARO_NIM      *nim,                         /* pointer to nim */
BOOL     *pnflag)                      /* True=enabled, False=disabled */
{
  unsigned long  ulRegVal;

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* enable PN bER */
  ulRegVal =  0x01;
  if (HAMARO_RegisterWrite(nim,CX2430X_BERERRORSEL,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  if (pnflag == NULL)
  {
    HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
    return(False);
  }

  *pnflag = (ulRegVal == 0UL ? False : True);

  return(True);

}  /* HAMARO_DRIVER_GetPNSequence() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_BBB_errinfo() */
/*******************************************************************************************************/
void            HAMARO_DRIVER_BBB_errinfo(    /* function for perform common error code for BERReadyCount[21:0], BYTE,Block */
HAMARO_NIM             *nim,                  /* pointer to nim */
long            *last_count,           /* last error count (when changed, error count is ready) */
HAMARO_CMPLXNO         *cpx,                  /* HAMARO_CMPLXNO holding result */
unsigned long   errwindow,             /* error window size */
unsigned long   errmult,               /* multiplier (different for BERReadyCount[21:0], BYTE, BLOCK and DVB */
HAMARO_MSTATUS         *mstat)                /* returned measurement status: (done, saturated, not-done) */
{
  unsigned long  ulRegVal;
  long   errcount;

  /* sample is not yet ready */
  HAMARO_DRIVER_set_complex(cpx,-1L,1UL);
  *mstat = HAMARO_MSTATUS_NOTDONE;

  /* read the window counter (this is the initial count) */
  if (HAMARO_RegisterRead(nim,CX2430X_BERSTART,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return;
    
  /* test if a sample is ready */
  if ((long)ulRegVal != *last_count)
  {
    /* save the current sample count */
    *last_count = (long)ulRegVal;

    /* freeze the counter */
    ulRegVal = 0x00;
    if (HAMARO_RegisterWrite(nim,CX2430X_BERSTART,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return;

    /* test for errwindow valid range, warn user if out of valid range */
    if (errwindow > 0xffUL)
    {
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_PARM_RANGE);
      errwindow = 0xffUL;
    }

    /* read the err counter */
    if (HAMARO_RegisterRead(nim,CX2430X_BERCOUNT_RS,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return;
    errcount = (long)ulRegVal;
    HAMARO_DRIVER_set_complex(cpx,errcount,(errwindow*errmult));
    *mstat = HAMARO_MSTATUS_DONE;

    /* restart the counter */
    ulRegVal = 0x01UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_BERSTART,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return;
  }

  return;

}  /* HAMARO_DRIVER_BBB_errinfo() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_error_measurements_off() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_error_measurements_off(   /* function to turn-OFF BER (i.e. BER, Byte, Block) settings */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* turn either HAMARO_PNBER or BER (ber, Byte, block) */
  if (HAMARO_DRIVER_BBB_error_off(nim) == False)  return(False);
  if (HAMARO_DRIVER_PNBER_error_off(nim) == False)  return(False);

  return(True);

}  /* HAMARO_DRIVER_error_measurements_off() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_BBB_error_off() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_BBB_error_off(            /* function to turn-OFF BER (i.e. BER, Byte, Block) settings */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* if any BER measurement is on, turn it off */
  if (nim->berbusy != -1L)  return(HAMARO_GetBER(nim,0UL,NULL,NULL));
  if (nim->bytebusy != -1L)  return(HAMARO_GetByteErrors(nim,0UL,NULL,NULL));
  if (nim->blockbusy != -1L)  return(HAMARO_GetByteErrors(nim,0UL,NULL,NULL));

  return(True);

}  /* HAMARO_DRIVER_BBB_error_off() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_errcount_disable() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_errcount_disable(         /* function to disable error count code */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  BOOL  rtn = True;

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  nim->berbusy = -1;
  nim->bytebusy = -1;
  nim->blockbusy = -1;

  if (HAMARO_RegisterWrite(nim,CX2430X_BERRSSELECT,HAMARO_RSERRCNT_NONE, HAMARO_DEMOD_I2C_IO) != True)  rtn = False;
  if (HAMARO_RegisterWrite(nim,CX2430X_BERRSINFWINEN,0L, HAMARO_DEMOD_I2C_IO) != True)  rtn = False;

  return(rtn);

}  /* HAMARO_DRIVER_errcount_disable() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_PNBER_error_off() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_PNBER_error_off(          /* function to turn-OFF PN BER settings */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* if PN BER measurement is on, turn it off */
  if (nim->pnberbusy != -1L)  return(HAMARO_GetPNBER(nim,HAMARO_PNBER_UNDEF,(HAMARO_CMPLXNO*)NULL,(HAMARO_MSTATUS*)NULL));

  return(True);

}  /* HAMARO_DRIVER_PNBER_error_off() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_Reset() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_Reset(                    /* function to perform a demod reset operation */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  unsigned long  ulRegVal;
  BOOL   rtn = True;

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* set demod registers to the default state */
  if (HAMARO_DRIVER_Default(nim) == False)  rtn = False; 
  
  /* reset the demod */
  ulRegVal = 0x01UL;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  rtn = False;
  
  ulRegVal = 0x00UL;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  rtn = False;

  return(rtn);

}  /* HAMARO_DRIVER_Reset() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_Preset() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_Preset(                   /* function to perform a demod preset operation */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  unsigned long  ulRegVal;
  BOOL   rtn = True;

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  /* preset the demod */
  ulRegVal = 0x02UL;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  rtn = False;