hamaro_drv.c

QPSK Tuner details, for conexant chipset.

  ulRegVal = 0x00UL;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  rtn = False;

  return(rtn);
}  /* HAMARO_DRIVER_Preset() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_Default() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_Default(                  /* function to set demod registers into a default state */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  int    i;
  int    j;

  unsigned long  ulTemp;
  unsigned char  addr;
  unsigned char   reg_skip[0xff+1];

  /* validate nim */
  HAMARO_DRIVER_VALIDATE_NIM(nim);

  memset(reg_skip,CNULL,sizeof(reg_skip));

  /* find each byte-wide non-RO register that is used */
  for (i = 0 ; i < CX2430X_REG_COUNT ; i++)
  {
    ulTemp = hamaro_demod_register_map[i].default_value;
    addr = hamaro_demod_register_map[i].address;
    if (hamaro_demod_register_map[i].access_level != HAMARO_REG_RO)
    {
        for (j = 0 ; j < 4 ; j++)
        {
            if (hamaro_demod_register_map[i].p_hw_mask[j] != 0)
            {
                /* Skip registers with values -1UL */
                if (ulTemp == 0xFFFFFFFFUL)  reg_skip[addr+j]++;
            }
        }
    }
  }

  /* skipping the soft reset register, step through each non-test register, set its default value  */
  /* (only if it has a default value to set) */
  for (i = 1 ; i < CX2430X_REG_COUNT ; i++)
  {
    /* only set default values for non-test registers (skip registers id'd as latching) */
    if ((hamaro_demod_register_map[i].address < HAMARO_MAX_HAMARO_NONTEST && hamaro_demod_register_map[i].access_level != HAMARO_REG_RO) &&
        (reg_skip[hamaro_demod_register_map[i].address] == 0) &&
        ((hamaro_demod_register_map[i].regfilter & HAMARO_REGF_COBRA) == HAMARO_REGF_COBRA))
    {
      /* grab the default value, if not -1, set register to its default value */
      ulTemp = hamaro_demod_register_map[i].default_value;
      if (ulTemp != 0xffffffffUL)
      {
        if (i == CX2430X_TUNI2CRPTSTART)
        {
            continue;
        }
		if (HAMARO_RegisterWrite(nim, (unsigned short)i, ulTemp, HAMARO_DEMOD_I2C_IO) == False)
		{
			return (False);
		}
      }
    }
  }

  /* peform Hamaro Default register set-up */
  if (HAMARO_DRIVER_Default_Hamaro(nim) == False)  return(False);

	if (HAMARO_RegisterWrite(nim, CX2430X_EQADAPTMODE, 0x0UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}
	if (HAMARO_RegisterWrite(nim, CX2430X_EQBWSEL, 0x0UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}

	if (HAMARO_RegisterWrite(nim, CX2430X_CTLINSEL, 0x1UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}
	if (HAMARO_RegisterWrite(nim, CX2430X_CTLAFCGAIN, 0x1UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}

	if (HAMARO_RegisterWrite(nim, CX2430X_LOCKBW, 0x1UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}
	if (HAMARO_RegisterWrite(nim, CX2430X_BTLBW, 0x0UL, HAMARO_DEMOD_I2C_IO) == False) 
	{
		return (False);
	}

	return(True);
}  /* HAMARO_DRIVER_Default() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_convert_twos() */
/*******************************************************************************************************/
long           HAMARO_DRIVER_convert_twos(    /* function to convert twos-comp no. read from demod into long */
unsigned long  numeric,                /* raw number read from demod */
int            bitslen)                /* count of lsb's to perform conversion on */
{
  long   lTemp;

  /* test MSB for 1, indicating a negative number */
  lTemp = (0x01L<<(bitslen-1));
  
  if (((unsigned long)lTemp&numeric) != 0x00UL)
  {
    /* gen a reverse mask, or into numeric */
    lTemp = ~(lTemp-1L);
    return((long)(numeric |= (unsigned long)lTemp));
  }
  
  return((long)numeric);

}  /* HAMARO_DRIVER_convert_twos() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_convert_twos_saturate() */
/*******************************************************************************************************/
unsigned long  HAMARO_DRIVER_convert_twos_saturate(   /* function to reduce a long integer's leading sign bits */
long           numeric,                        /* long integer in 2's complement notation */
int            bitslen)                        /* reduced bit count of the long integer */
{
  long  lTemp = 0L;
  unsigned long ulTemp;

  if (numeric >= 0)
  {
    /* positive number */
    if (numeric >= (0x01L<<(bitslen-1))-1)  lTemp = ((0x01L<<(bitslen-1L))-1L);
    else lTemp = numeric;
  }
  else
  {
    /* negative number */
    if (numeric < ((0x01L<<(bitslen-1))*-1L))  lTemp = ((0x01L<<(bitslen-1))*-1L);
    else lTemp = numeric;
  }

  /* remove leading sign bits for negative number */
  ulTemp = (unsigned long)(lTemp & ((0x01UL << bitslen) - 1));
  return (ulTemp);

}  /* HAMARO_DRIVER_convert_twos_saturate() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_HardReset() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_HardReset(                /* function to perform a total SW reset of the demod */
HAMARO_NIM   *nim)                            /* pointer to nim */
{
  unsigned long  ulRegVal;

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

  /* perform a SW hard reset */
  ulRegVal = 0xff;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  
  ulRegVal = 0x0;
  if (HAMARO_RegisterWrite(nim,CX2430X_RSTHAMARO,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  return(True);

}  /* HAMARO_DRIVER_HardReset() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_CxType() */
/*******************************************************************************************************/
BOOL   HAMARO_DRIVER_CxType(                  /* function to perform a total SW reset of the demod */
HAMARO_NIM    *nim,                           /* pointer to nim */
HAMARO_DEMOD  *demod,                         /* pointer to storage holding demod id'd by sw */
char   **demod_str)                    /* demod string built using demod* (above) */
{

  int   err = 0;
  unsigned char  ver;
  
  /* Confirm that the chip-type is Hamaro */
  if (HAMARO_ReadReg(nim,0x00,&ver) != True)  err++;

  /* determine the chip-type */
  switch (ver)
  {
	case 0xde:
    {
      *demod = HAMARO_CX2430X;
      if (demod_str != NULL)  *demod_str = HAMARO_PRODUCT_NAME_STRING_HAMARO;
      return(True);
    }
    default:
    {
      /* unknown chip detected (unknown chip-id) */
      err++;
      break;
    }
  }  /* switch() */

  if (err == 0)  return(True);
  
  /* unable to querry chip to determine type */
  HAMARO_DRIVER_SET_ERROR(nim,HAMARO_CXTYPE);
  return(False);

}  /* HAMARO_DRIVER_CxType() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_AcqSetViterbiSearchList() */
/*******************************************************************************************************/
BOOL     HAMARO_DRIVER_AcqSetViterbiSearchList(  /* function to set viterbi search settings */
HAMARO_NIM      *nim,                            /* pointer to nim */
HAMARO_VITLIST  *vitlist)                        /* viterbi search list settings */
{
  int   i;

  unsigned long  ulRegVal;
  unsigned char  vitsetting = 0;

  HAMARO_TRANSPEC  transpec;

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

  if (vitlist != NULL)
  {
    /* read the trans spec */
    if (HAMARO_GetTransportSpec(nim,&transpec) == True)
    {
      int  j;
      HAMARO_CODERATE  coderatefromlist;

      switch(transpec)
      {
        case  HAMARO_SPEC_DVB:
        {
          /* step through each element of vitlist */
          for (i = 0 ; i < HAMARO_min(vitlist->vcnt,HAMARO_MAX_VLIST) ; i++)
          {
            /* save coderate from vitlist */
            coderatefromlist = vitlist->viterbi_list[i];
            if (coderatefromlist != HAMARO_CODERATE_NONE)
            {
              /* search possible coderates for transpec, or into vitsetting */
              for (j = 0 ; dvb_cr_list[j] != HAMARO_CODERATE_NONE ; j++)
              {
                if (dvb_cr_list[j] == coderatefromlist)
                {
                  vitsetting = (unsigned char)(vitsetting | (0x01<<(dvb_cr_equate[j])));
                  break;
                }
              }
            }
          }
          break;
        }
        default:
        {
          HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
          return(False);
          break;
        }
      }  /* switch(... */

      /* if viterbi setting is to be 0, flag action to caller, but continue */
      if (vitsetting == 0x00)  HAMARO_DRIVER_SET_ERROR(nim,HAMARO_VITSETTING);

      /* write viterbi search settings to demod */
      ulRegVal = (unsigned long)vitsetting;
      if (HAMARO_RegisterWrite(nim,CX2430X_ACQCREN,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
      return(True);
    }
    
    /* demod has reported a transpec setting that is not valid */
    HAMARO_DRIVER_SET_ERROR(nim,HAMARO_DEMOD_ERR);
    return(False);
  }

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

}  /* HAMARO_DRIVER_AcqSetViterbiSearchList() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_AcqGetViterbiSearchList() */
/*******************************************************************************************************/
BOOL     HAMARO_DRIVER_AcqGetViterbiSearchList(  /* function to retrieve  HAMARO_NIM's current viterbi search list settings */
HAMARO_NIM      *nim,                            /* pointer to nim */
HAMARO_VITLIST  *vitlist)                        /* returned current settings */
{
  int    i;
  int    j;

  unsigned long  ulRegVal;
  unsigned char  vitsetting = 0;

  HAMARO_TRANSPEC  transpec;

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

  if (vitlist != NULL)
  {
    /* read vit search settings from demod */
    if (HAMARO_RegisterRead(nim,CX2430X_ACQCREN,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
    vitsetting = (unsigned char)ulRegVal;

    /* read the trans spec */
    if (HAMARO_GetTransportSpec(nim,&transpec) == True)
    {
      unsigned char  mask;

      /* building new vitlist, so clear count, clear list */
      vitlist->vcnt = 0;
      for (i = 0 ; i < HAMARO_MAX_VLIST ; i++)  vitlist->viterbi_list[i] = HAMARO_CODERATE_NONE;

      /* step through each bit of vit searching settings from demod */
      for (i = 0 ; i < 8 ; i++)
      {
        /* gen the mask to look for */
        mask = (unsigned char)(0x01U<<i);
      
        if ((vitsetting&mask) != 0)
        {
          switch(transpec)
          {