hamaro_drv.c

QPSK Tuner details, for conexant chipset.

  /* turn-on (i.e. Enable) the clock smoother if desired */
  if (HAMARO_DRIVER_SetSmoothClockEn(nim,cs) != True)  return(False);

  return(True);

}  /* HAMARO_DRIVER_SetSmoothClock() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetSmoothClockEn() */
/*******************************************************************************************************/
BOOL           HAMARO_DRIVER_SetSmoothClockEn(/* funct to set the clock smoother MPEG Enable register */
HAMARO_NIM            *nim,                   /* pointer to nim */
HAMARO_CLOCKSMOOTHSEL cs)                     /* clk smoother setting */
{
   unsigned long  ulRegVal;

   /* turn-on/off clock smoother */
   switch  (cs)
   {
      case  HAMARO_CLK_SMOOTHING_OFF:
      {
         ulRegVal = 0UL;
         break;
      }
      case  HAMARO_DDS_LEGACY_SMOOTHING:
      {
         ulRegVal = 1UL;
         break;
      }
      case  HAMARO_PLL_ADVANCED_SMOOTHING:
      {
         ulRegVal = 3UL;
         break;
      }
      default:
      {
         /* invalid smoother selection passed to function (flow through to CLK_SMOOTHER_OFF (also Default) ) */
         HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_PARM);
         return (False);
      }
   }  /* switch(... */

    if (HAMARO_RegisterWrite(nim,CX2430X_MPGCLKSMOOTHSEL,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)
    {
        return(False);
    }

   return (True);

}  /* HAMARO_DRIVER_SetSmoothClockEn() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetLNBMode() */
/*******************************************************************************************************/
BOOL     HAMARO_DRIVER_SetLNBMode(            /* function to set-up LNB tone output options */
HAMARO_NIM      *nim,                         /* pointer to HAMARO_NIM */
HAMARO_LNBMODE  *lnbmode)                     /* pointer to struct containing LNB tone output settings */
{
  unsigned long  ulRegVal;

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

  /* write the LNB set-up registers */
  ulRegVal = lnbmode->cycle_count;
  if (HAMARO_RegisterWrite(nim,CX2430X_LNBBURSTLENGTH,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  ulRegVal = (unsigned long)lnbmode->lnb_mode;
  if (HAMARO_RegisterWrite(nim,CX2430X_LNBMODE,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  return(True);

}  /* HAMARO_DRIVER_SetLNBMode() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SendDiseqc() */
/*******************************************************************************************************/
BOOL          HAMARO_DRIVER_SendDiseqc(       /* function to set-up and control the output of Diseq messages */
HAMARO_NIM           *nim,                    /* pointer to HAMARO_NIM */
unsigned char *msg,                    /* message to send */
unsigned char msg_len,                 /* length of message */
BOOL          msg_long,                /* TRUE if this message is part of a longer message */
BOOL          last_msg)                /* TRUE if this is the last message */
{
  int   i;

  BOOL  done;

  unsigned long  ulRegVal;
  unsigned char  b;
  unsigned long  max_loop;

  /* test size of message to determine how to proceed */
  if (msg_len <= 6)
  {
    /* test for a short message */
    if (msg_len < 3)  
    {
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_LNB_MSGLEN);
      return(False);
    }

    /* send message to the demod */
    for (i = 0 ; i < msg_len ; i++)
    {
      /* fill the message into the demod's lnb message buffer */
      b = msg[i];
      if (HAMARO_WriteReg(nim,(unsigned char)(i + hamaro_demod_register_map[CX2430X_LNBMSG1].address),&b) == False)  return(False);
    }

    /* set length of message */
    ulRegVal = ((unsigned long)msg_len - 3UL);
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBMSGLENGTH,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  }
  else
  {
    /* indicate to caller that a long lnb message was attempted */
    HAMARO_DRIVER_SET_ERROR(nim,HAMARO_LNB_MSGLEN);
    return(False);
  }

  /* (CR 7488, CR 7489) set LONGMSG flag on long message, reset MOREMSG flag */
  if (msg_long == True)
  {
    ulRegVal = 0x01UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBLONGMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

    ulRegVal = 0x00UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBMOREMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  }
  else if (last_msg == True)
  {
    ulRegVal = 0x00UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBLONGMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

    ulRegVal = 0x00UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBMOREMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  }
  else
  {
    /* message is no longer composed of multi-parts, so reset LONGMSG flag */
    ulRegVal = 0x00UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBLONGMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

    ulRegVal = 0x01UL;
    if (HAMARO_RegisterWrite(nim,CX2430X_LNBMOREMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
  }

  /* send the message (or last part of the message, if a long message) */
  ulRegVal = 0x01;
  if (HAMARO_RegisterWrite(nim,CX2430X_LNBSENDMSG,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);

  /* loop until message has been delivered */
  max_loop = 0UL;
  done = False;
  do
  {
    /* test for stalled demod (inability to send diseqc message for some reason) */
    if (max_loop > HAMARO_MAX_LNBMSGWAITOSW)
    {
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_LNB_STALLED);
      return(False);
    }

    /* test if message has been sent, if so, return */
    if (HAMARO_RegisterRead(nim,CX2430X_LNBSENDMSG,&ulRegVal, HAMARO_DEMOD_I2C_IO) == False)  return(False);
    if (ulRegVal == 0x01UL)  done = True;

    /* message has not been delivered, so loop until delivered, or time expires */
    max_loop++;
  }  while (done == False);

  return(True);

}  /* HAMARO_DRIVER_SendDiseqc() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetTunerFrequency() */
/*******************************************************************************************************/
BOOL           HAMARO_DRIVER_SetTunerFrequency(         /* function to set tuner frequency */
HAMARO_NIM            *nim,                             /* pointer to nim */
unsigned long  freq)                             /* frequency to be set */
{
   /* test for valid nim */
    HAMARO_DRIVER_VALIDATE_NIM(nim);

   /* make sure the tuner frequency to be set is within the LNB search range */
   if (HAMARO_DRIVER_ValidTunerFreqRange(nim, freq) == False)
   {
      return (False);
   }

   if (HAMARO_TUNER_SetFrequency(nim,freq) == False)
   {
      return (False);
   }
   return (True);
}  /* HAMARO_DRIVER_SetTunerFrequency() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_ValidTunerFreqRange() */
/*******************************************************************************************************/
BOOL           HAMARO_DRIVER_ValidTunerFreqRange(       /* function to test if the tuner frequency is within
                                                    the LNB search range */
HAMARO_NIM            *nim,                             /* pointer to nim */
unsigned long  freq)                             /* tuner frequency  */
{
   unsigned long  ulTemp;

   /* test for valid nim */
    HAMARO_DRIVER_VALIDATE_NIM(nim);

   /* make sure the tuner frequency is within the LNB search range */
   ulTemp = (freq > nim->freq_ideal) ? (freq - nim->freq_ideal) : (nim->freq_ideal - freq);
   if (ulTemp > nim->lnboffset)
   {
      HAMARO_DRIVER_SET_ERROR(nim,HAMARO_BAD_TUNER_FREQ);
      return (False);
   }

   return (True);

}  /* DRIVER_ValidTunerFreqRange() */

/*******************************************************************************************************/
/* HAMARO_DRIVER_SetSoftDecisionThreshold() */
/*******************************************************************************************************/
BOOL  HAMARO_DRIVER_SetSoftDecisionThreshold(  /* funct to select and set demod soft decision threshold */
HAMARO_NIM   *nim)                             /* pointer to nim */
{
   HAMARO_TRANSPEC  tran;
   HAMARO_CODERATE  cr;
   long      softdec = -1L;

   unsigned long  ulRegVal;

   if (HAMARO_GetTransportSpec(nim,&tran) == False)
   {
      return (False);
   }

   if (HAMARO_GetViterbiRate(nim,&cr) == False)
   {
      return (False);
   }

   switch (tran)
   {
      case  HAMARO_SPEC_DVB:
      {
         if (cr == HAMARO_CODERATE_1DIV2)
         {
            softdec = 1L;
         }
         else
         {
            softdec = 0L;
         }
         break;
      }

      default:
      {
         break;
      }
   }  /* switch */

   if (softdec != -1L)
   {
      ulRegVal = (unsigned long)softdec;
      if (HAMARO_RegisterWrite(nim,CX2430X_DMDSDTHRESH,ulRegVal, HAMARO_DEMOD_I2C_IO) == False)
      {
         return (False);
      }
   }

   return (True);

}  /* HAMARO_DRIVER_SetSoftDecisionThreshold() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetTunerFilterBWVoltage() */
/*******************************************************************************************************/
BOOL          HAMARO_DRIVER_SetTunerFilterBWVoltage(  /* funct to set the voltage that controls tuner anti-alias filter BW */
HAMARO_NIM           *nim,                            /* pointer to nim */
unsigned long mV)                              /* the voltage in mV to set (max 3.3 volt) */
{
	unsigned long  ulRegVal;
	long  lSigmaDelta;

	if (nim->tuner_type == HAMARO_CX24108)
	{
		/* lSigmaDelta = (mV * 0.3126) - 512 */
		lSigmaDelta = 0;
		if (mV != 0UL)
		{
			lSigmaDelta = (long)mV * 3126L;
			lSigmaDelta /= 10000L;
		}
		lSigmaDelta -= 512L;

		/* the CX2430X_FILVALUE register takes 10 bit value in 2's complement format */
		ulRegVal = HAMARO_DRIVER_convert_twos_saturate(lSigmaDelta,HAMARO_Register_bitlength(CX2430X_FILVALUE));		
		if (HAMARO_RegisterWrite(nim, CX2430X_FILVALUE9_2, (ulRegVal >> 2UL), HAMARO_DEMOD_I2C_IO) == False)
		{
			return (False);
		}
		if (HAMARO_RegisterWrite(nim, CX2430X_FILVALUE1_0, (ulRegVal & 0x3UL), HAMARO_DEMOD_I2C_IO) == False)
		{
			return (False);
		}
	}
	return (True);
}  /* HAMARO_DRIVER_SetTunerFilterBWVoltage() */


/*******************************************************************************************************/
/* HAMARO_DRIVER_SetRSCntlPin() */
/*******************************************************************************************************/
BOOL            HAMARO_DRIVER_SetRSCntlPin(            /* Function to set MPEG RS Cntl pin setting */
HAMARO_NIM             *nim,                           /* pointer to nim */
HAMARO_REGIDX          regIdx,                         /* index to the target register */
HAMARO_RS_CNTLPIN_SEL  RSCntlPinSel)                   /* RS pin setting */
{
   const unsigned long ulRegValueMap[] = {0x03, 0x00, 0x01, 0x02, 0x03};
   /* ulRegValueMap[HAMARO_RS_CNTLPIN_START]     = ulRegValueMap[1] = 0x00 */
   /* ulRegValueMap[HAMARO_RS_CNTLPIN_VALID]     = ulRegValueMap[2] = 0x01 */
   /* ulRegValueMap[HAMARO_RS_CNTLPIN_FAIL]      = ulRegValueM