hamaro_cx24128.c

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

         {
            return (True);
         }
      }
   }
   /* still cannot lock??? */
   return (False);
}


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetReferenceFreq() 
 * sets the current reference frequency value to tuner register and nim
 *******************************************************************************************************/
static BOOL     
HAMARO_TUNER_CX24128_SetReferenceFreq(HAMARO_NIM       *p_nim,     /* pointer to nim */
                                     HAMARO_RFREQVAL  rfreqvalue) /* reference frequency value */
{
   unsigned char reg_value, reg_val_temp;
   reg_val_temp = (unsigned char)rfreqvalue;
   HAMARO_TUNER_CX24128_VALIDATE(p_nim);
   if (p_nim->tuner.cx24128.vcodiv == HAMARO_VCODIV4 && p_nim->tuner.cx24128.chipid == HAMARO_VIPER_CHIP_ID) /* CR 21579 */
   {
      reg_val_temp |= 0x01;
   }
   /* read 0x02 */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x02), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   /* write to 0x02[1], clear 0x02[1] */ 
   reg_value &= 0xFD; /* clear 0x02[1] */
   reg_value |= (reg_val_temp << 1);
   if(HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x02), (unsigned long)reg_value, HAMARO_IO_UNKNOWN) != True)  
      return(False);	
   return(True);
}  /* HAMARO_TUNER_CX24128_SetReferenceFreq() */


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetClkInversion() 
 * sets the clock inversion to both nim structure and to tuner register
 *******************************************************************************************************/
BOOL     
HAMARO_TUNER_CX24128_SetClkInversion(HAMARO_NIM     *p_nim,       /* pointer to nim */
                              BOOL    clkinversion) /* clock inversion value */
{
   unsigned char reg_value;
   HAMARO_TUNER_CX24128_VALIDATE(p_nim);
   p_nim->tuner.cx24128.clkinversion = clkinversion;

   /* read 0x10, clear 0x10[7] */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x10), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value &=0x7F;
   reg_value |= (unsigned char)clkinversion <<7;
   /* set to 0x10[7] */
   if(HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x10), (unsigned long)reg_value, HAMARO_IO_UNKNOWN) != True)  
      return(False);
   return(True);
}  /* HAMARO_TUNER_CX24128_SetClkInversion() */


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetEnableRegister() 
 * sets the enable bits to tuner
 *******************************************************************************************************/
BOOL     
HAMARO_TUNER_CX24128_SetEnableRegister(HAMARO_NIM     *p_nim,       /* pointer to nim */
                                unsigned char enable) /* enable bits */
{
   unsigned char reg_value;
   
   HAMARO_TUNER_CX24128_VALIDATE(p_nim);
   
   /* read 0x21 and clear 0x21[5:0] */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x21), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value &= 0xC0;
   reg_value |= enable;  
#if HAMARO_INCLUDE_RATTLER
   /* Rattler specific; Enable FTA LNA */
   if (p_nim->tuner_type == HAMARO_CX24113)
      reg_value |= 0x02;
#endif   
   /* set to 0x21[5:0] */
   if(HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x21), reg_value, HAMARO_IO_UNKNOWN) != True)  
      return(False);   
   return(True);
}  /* HAMARO_TUNER_CX24128_SetEnableRegister() */


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_GlobalSetRefSelSpi() 
 * Program the global ref_sel_spi bit
 *******************************************************************************************************/
static BOOL
HAMARO_TUNER_CX24128_GlobalSetRefSelSpi(HAMARO_NIM* p_nim, unsigned char value)
{
   unsigned char reg_value;
   /* read 0x02 and clear 0x02[1] */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x02), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value &= 0xFB; /* clear 0x02[1] */
   reg_value |= (value & 0x01) << 1;
   if(HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x02), (unsigned long)reg_value, HAMARO_IO_UNKNOWN) != True)  
      return(False);   
	return (True);
}
/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_powerup() 
 * performs tuner power-up reset 
 *******************************************************************************************************/
BOOL        
HAMARO_TUNER_CX24128_powerup(HAMARO_NIM  *p_nim)  /* pointer to nim */
{
   unsigned char chipid;
   HAMARO_VIPERPARMS    viperparms;
   unsigned long ulTemp;
   HAMARO_CX24128_refresh_tuner_pll_lock = True; 
   
   
   /* determine the io method */
   if (p_nim->demod_type == HAMARO_CX24130 || p_nim->demod_type == HAMARO_CX24121) /* supports only BTI mode */
   {
      /* Initialize the register offset in case of dual tuner system */
      p_nim->tuner.cx24128.register_offset = (unsigned char)HAMARO_GET_CX24128_BTI_REGISTER_OFFSET(p_nim->demod_handle);
   }
   else /* supports I2C repeater mode */
   {
      /* Initialize the register offset in case of dual tuner system */
      p_nim->tuner.cx24128.register_offset = (unsigned char)HAMARO_GET_CX24128_I2C_REGISTER_OFFSET(p_nim->demod_handle);
      p_nim->tuner.cx24128.io_method = HAMARO_VIPER_I2C_IO;
   }
   
   if (p_nim->tuner.cx24128.io_method == HAMARO_VIPER_I2C_IO)
   {
      /* First of all, detect the I2C address of Mongoose or Viper. */
      /* Try I2C address 1, read chip ID. */
      if (HAMARO_TUNER_CX24128_EnableDemodRepeaterMode(p_nim) == False)
      {
         return (False);
      }
      
      
      HAMARO_SET_DEMOD_HANDLE_I2C_ADDR(p_nim->tuner.cx24128.tuner_handle, HAMARO_CX24128_I2C_ADD1);
      /* Read 0x00 chipid */
      HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x00), (unsigned long*)&chipid, HAMARO_IO_UNKNOWN);
	  
      
      if ((chipid != HAMARO_VIPER_CHIP_ID) && (chipid != MONGOOSE_CHIP_ID)) /* Check address 2. */
      {
      
         HAMARO_SET_DEMOD_HANDLE_I2C_ADDR(p_nim->tuner.cx24128.tuner_handle, HAMARO_CX24128_I2C_ADD2);
         /* Read 0x00 chipid */		 
         HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x00), (unsigned long*)&chipid, HAMARO_IO_UNKNOWN);
         /* check chip ID, make sure it is Mongoose/Viper. */
         if ((chipid != HAMARO_VIPER_CHIP_ID) && (chipid != MONGOOSE_CHIP_ID))
         {
            return(False);
         }		 
      }
      p_nim->tuner.cx24128.chipid = (unsigned char)chipid;
	  
      /* Keep the chip ID value. */
      if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x01), (unsigned long *)&ulTemp, HAMARO_IO_UNKNOWN) != True)  
      {
         return(False);
      }
       
	p_nim->tuner.cx24128.version = (unsigned char)ulTemp;
	
   }
   
   p_nim->tuner.cx24128.tuner_gain_thresh = -50; /* -50dBm default */
   p_nim->tuner.cx24128.gain_setting_selection = HAMARO_SIGNAL_LEVEL_LOW;
   
   /* Set reference frequency to use crystal frequency. */
   if (HAMARO_TUNER_CX24128_SetReferenceFreq(p_nim, HAMARO_RFREQ_0) != True) 
   {
      return(False);
   }
   
   /* Set parameters. */
   /* Initialize ICP parameters. */   
   viperparms.ICPmode = HAMARO_ICPMODE_AUTO;       /* ICP auto mode by default. */           
   
   /* The folowing values are for XTAL < 11 MHz */
   if (p_nim->xtal < HAMARO_CX24128_ICP_XTAL_THRESH)
   {
      viperparms.ICPauto_Hi    = HAMARO_ICPAUTO_LEVEL4;     /* Auto analog ICP levels, 2.0 mA */
      viperparms.ICPauto_MedHi = HAMARO_ICPAUTO_LEVEL4;     /* 2.0 mA */
      viperparms.ICPauto_MedLo = HAMARO_ICPAUTO_LEVEL4;     /* 2.0 mA */
      viperparms.ICPauto_Lo    = HAMARO_ICPAUTO_LEVEL3;     /* 1.5 mA */
   }
   else /* The folowing values are for XTAL > 11 MHz */
   {      
      viperparms.ICPauto_Hi    = HAMARO_ICPAUTO_LEVEL4;     /* Auto analog ICP levels, 2.0 mA */
      viperparms.ICPauto_MedHi = HAMARO_ICPAUTO_LEVEL4;     /* 2.0 mA */
      viperparms.ICPauto_MedLo = HAMARO_ICPAUTO_LEVEL3;     /* 1.5 mA */
      viperparms.ICPauto_Lo    = HAMARO_ICPAUTO_LEVEL2;     /* 1.0 mA */
   }
   
   viperparms.ICPdig = HAMARO_ICPDIG_LEVEL3;      /* 2.0 times */
   viperparms.ICPman = HAMARO_ICPMAN_LEVEL1;       /* ICP manual mode default. */
   viperparms.ACP_on = True;             /* Analog CP off by default. */
   /* Initialize VCO parameters. Include set VCO mode to be AUTO. */   
   viperparms.VcoMode    = HAMARO_VCOMODE_AUTO;
   viperparms.Vcobs      = HAMARO_VCOBANDSHIFT_HIGH;
   viperparms.VcobandSel = HAMARO_VCOBANDSEL_1;
   viperparms.Bsdelay    = 0x08;             /* Band sel delay value, default is 8 */
   
   /* Band sel freq cnt */
   viperparms.Bsfreqcnt = 0x0FFF;          
   /* Band sel ref div value */
   viperparms.Bsrdiv    = 0x0FFF; 
   
   /* Initialize other parameters. */
   viperparms.PrescalerMode = False;
   
   /* Enable hardware parts. */
   HAMARO_TUNER_CX24128_SetEnableRegister(p_nim, 0x3D); /* FTA LNA is disabled */
   
   #if HAMARO_INCLUDE_RATTLER
   if (p_nim->tuner_type == HAMARO_CX24113) /* Rattler specific */
   {
      viperparms.lna_gain = HAMARO_LNA_MAX_GAIN; /* LNA gain (max) */
   }
   #endif /*HAMARO_INCLUDE_RATTLER */
   
   /* -- Mongoose RevB -- */
   viperparms.RFVGABiasControl = False; /* Disable (=1) RFVGA bias control circuit */
   
   /* Set parameters to tuner and nim. */
   HAMARO_TUNER_CX24128_SetParameters(p_nim, &viperparms);
   
   /* Set Gain default values. */
   HAMARO_TUNER_CX24128_SetGainSettings(p_nim, 0UL);
   
   /* Set BW default settings. */
   HAMARO_TUNER_CX24128_SetFilterBandwidth(p_nim, 18025UL);
   
   /* Set DSM clk inversion. */
   HAMARO_TUNER_CX24128_SetClkInversion(p_nim, True);
   /* Enable F window as default. */
   HAMARO_FWindowEnable = True;
   
   /* Set the Mongoose ref clock output (HAMARO_CX24128_REFSEL_SPI_DIV1 is the default setting) */
   if (p_nim->xtal >= HAMARO_CX24128_A3_XTAL_FREQ) /* div 2 for A3 */
   {
      if (HAMARO_TUNER_CX24128_GlobalSetRefSelSpi(p_nim, HAMARO_CX24128_REFSEL_SPI_DIV2) != True)
      {
         return(False);
      }
   }
   else
   {
      if (HAMARO_TUNER_CX24128_GlobalSetRefSelSpi(p_nim, HAMARO_CX24128_REFSEL_SPI_DIV1) != True)
      {
         return(False);
      }
   }
   return(True);
}/* HAMARO_TUNER_CX24128_powerup() */


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetReferenceDivider() 
 * sets the current reference divider value to nim only
 *******************************************************************************************************/
BOOL     
HAMARO_TUNER_CX24128_SetReferenceDivider(HAMARO_NIM     *p_nim,  /* pointer to nim */
                                        HAMARO_RDIVVAL  rvalue) /* reference divider value */
{
  HAMARO_TUNER_CX24128_VALIDATE(p_nim);

	if (p_nim->tuner.cx24128.vcodiv == HAMARO_VCODIV4 && p_nim->tuner.cx24128.chipid == HAMARO_VIPER_CHIP_ID) /* CR 21579 */
	{
		rvalue = HAMARO_RDIV_2;
	}
  
  
	if (p_nim->tuner.cx24128.chipid == HAMARO_VIPER_CHIP_ID && p_nim->tuner.cx24128.register_offset != 0) /* Tuner B */ 
	{
		if (p_nim->xtal >= HAMARO_CX24128_A3_XTAL_FREQ) /* Always set reference division ratio to /2 for A3 */
	    {
            rvalue = HAMARO_RDIV_2;
	    }		
    }

  switch(rvalue)
  {
    case  HAMARO_RDIV_1:
    case  HAMARO_RDIV_2:
    {
		p_nim->tuner.cx24128.R = rvalue;
		break;
    }
    default:
    {
      HAMARO_DRIVER_SET_ERROR(p_nim,HAMARO_TUNERREF);
      return(False);
      break;
    }
  }  /* switch(... */

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

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_GetReferenceFreq() 
 * retrieves current reference frequency value from nim
 *******************************************************************************************************/
BOOL      
HAMARO_TUNER_CX24128_GetReferenceFreq(HAMARO_NIM       *p_nim,    /* pointer to nim */
                               HAMARO_RFREQVAL  *p_fvalue) /* pointer to HAMARO_RFREQVAL where value is returned to caller */
{
	HAMARO_TUNER_CX24128_VALIDATE(p_nim);
  
	*p_fvalue = p_nim->tuner.cx24128.rfreqval;

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


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetVcoDivider() 
 * sets the vco divider to nim structure 
 *******************************************************************************************************/
BOOL     
HAMARO_TUNER_CX24128_SetVcoDivider(HAMARO_NIM     *p_nim, /* pointer to nim */
                            HAMARO_VCODIV  vcodiv) /* vco divider value */
{
	HAMARO_TUNER_CX24128_VALIDATE(p_nim);

	p_nim->tuner.cx24128.vcodiv = vcodiv;

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

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_GetParameters() 
 * returns current tuner parameter settings to the caller 
 *******************************************************************************************************/
BOOL        
HAMARO_TUNER_CX24128_GetParameters(HAMARO_NIM         *p_nim,        /* pointer to nim */
                            HAMARO_VIPERPARMS  *p_viperparms) /* pointer to HAMARO_VIPERPARMS, where copy will be written */
{
   unsigned char reg_value,reg_val_temp;
   
   HAMARO_TUNER_CX24128_VALIDATE(p_nim);
   
   if (p_viperparms == 0)  
   {
      return(False);
   }
   
   /* copy tunerparms to caller storage */
   memcpy(p_viperparms, &p_nim->tuner.cx24128.viperparms, sizeof(HAMARO_VIPERPARMS));
   
   /* Read 0x18[0] */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x18), (unsigned long*)&reg_val_temp, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value = reg_val_temp & 0x01;
   p_viperparms->Vcobs = (HAMARO_VCOBANDSHIFT)reg_value;
   
   /* Read 0x18[5:1] */