hamaro_cx24128.c

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

/* hamaro_cx24128.c */

/*+++ *******************************************************************\
*
*   Copyright and Disclaimer:
*
*       ---------------------------------------------------------------
*       ALL SOFTWARE, APPLICATIONS, DOCUMENTATION, OR MATERIALS        
*       FURNISHED HEREIN IS PROVIDED *AS IS*.  CONEXANT DOES NOT MAKE  
*       ANY WARRANTIES, EITHER EXPRESS OR IMPLIED, AND HEREBY EXPRESSLY
*       DISCLAIMS ANY AND ALL SUCH WARRANTIES TO THE EXTENT PERMITTED  
*       BY LAW, INCLUDING, SPECIFICALLY, ANY IMPLIED WARRANTY ARISING  
*       BY STATUTE OR OTHERWISE IN LAW OR FROM A COURSE OF DEALING OR  
*       USAGE OF TRADE.  CONEXANT DOES NOT MAKE ANY WARRANTIES, EITHER 
*       EXPRESS OR IMPLIED, AND HEREBY EXPRESSLY DISCLAIMS ANY AND ALL 
*       SUCH WARRANTIES WITH RESPECT TO ALL SOFTWARE, APPLICATIONS,    
*       DOCUMENTATION, AND MATERIALS INCLUDING ALL IMPLIED WARRANTIES  
*       OF MERCHANTABILITY, OR OF MERCHANTABLE QUALITY, OR OF FITNESS  
*       FOR ANY PURPOSE, PARTICULAR, SPECIFIC OR OTHERWISE, OR OF      
*       NONINFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OF OTHERS,     
*       RELATING TO THE SOFTWARE, APPLICATIONS, OPERATION,             
*       DOCUMENTATION, DATA OR RESULTS GENERATED BY THE OPERATION OR   
*       USE THEREOF, AND MATERIALS PROVIDED HEREIN.  THE ENTIRE RISK AS
*       TO THE SUBSTANCE, QUALITY AND PERFORMANCE OF SOFTWARE,         
*       APPLICATIONS, AND DOCUMENTATION DESCRIBING SUCH SOFTWARE       
*       REMAINS WITH THE BUYER.                                        
*                                                                      
*       REGARDLESS OF WHETHER ANY REMEDY SET FORTH HEREIN FAILS OF ITS 
*       ESSENTIAL PURPOSE OR OTHERWISE, CONEXANT SHALL NOT BE LIABLE   
*       FOR ANY EXEMPLARY, SPECIAL, PUNITIVE, SPECULATIVE, INDIRECT,   
*       CONSEQUENTIAL OR INCIDENTAL DAMAGES OF ANY KIND (INCLUDING     
*       WITHOUT LIMITATION LOST PROFITS, LOSS OF INCOME, LOSS OF       
*       GOODWILL, OR OTHER TANGIBLE OR INTANGIBLE BUSINESS LOSS)       
*       ARISING OUT OF OR IN CONNECTION WITH, DIRECTLY OR INDIRECTLY,  
*       SOFTWARE, APPLICATIONS, DOCUMENTATION, OR ANY SERVICES OR      
*       MATERIALS PROVIDED HEREUNDER, OR USE OR INABILITY TO USE THE   
*       SOFTWARE, EVEN IF CONEXANT HAS BEEN ADVISED OF THE POSSIBILITY 
*       OF SUCH DAMAGES.                                               
*
*       Copyright (c) 2001 Conexant Systems, Inc.
*       All Rights Reserved.
*       ---------------------------------------------------------------
*
*   Module Revision Id:
*
*       $Header:hamaro_cx24128.c, 75, 6/2/2005 8:49:57 PM, Amarnath Puttur$
*
*   Abstract:
*
*       Contains CX24128-specific software.
*
\******************************************************************* ---*/

#include "hamaro.h"                     /* Hamaro include files, ordered */

#if HAMARO_INCLUDE_VIPER
extern void TunerSBWrite( unsigned long demod_handle, unsigned char reg_addr, unsigned long data, unsigned long *status );
extern unsigned long TunerSBRead( unsigned long demod_handle, unsigned char reg_addr, unsigned long *status );
extern const HAMARO_REGISTER_MAP hamaro_viper_register_map[];

static const unsigned char vco_and_band_selection[] = {
/* VCO1L, VCO1H, VCO2L, VCO2H, VCO3L, VCO3H, VCO4L, VCO4H, VCO5L, VCO5H, VCO6L, VCO6H */
   0x21,  0x20,  0x11,  0x10,  0x09,  0x08,  0x05,  0x04,  0x03,  0x02,  0x81,  0x80};

/* Variables visible to this file only */
BOOL HAMARO_CX24128_refresh_tuner_pll_lock;  /* Shadowing flag */
BOOL HAMARO_CX24128_tuner_pll_lock;          /* Tuner pll lock status (uses HAMARO_CX24128_refresh_tuner_pll_lock) */

BOOL HAMARO_CX24128_refresh_tuner_pll_freq;   /* Shadowing flag */
unsigned long  HAMARO_CX24128_tuner_pll_freq; /* HAMAROTuner PLL frequency (uses refresh_tuner_pll_freq)   */  



/**************************************** I2C repeater functions ***************************************/

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_SetDemodRepeaterMode() 
 * sets the demod to be in repeater Mode
 *******************************************************************************************************/
//JLIN - Don't know if this is necessary anymore.  

BOOL HAMARO_TUNER_CX24128_SetDemodRepeaterMode(HAMARO_NIM* p_nim)
{
   
   unsigned char  ucRegVal;
   if (p_nim->demod_type == HAMARO_CX2430X)
   {
      ucRegVal = (p_nim->SBRead)(p_nim->demod_handle, 0x23, &p_nim->iostatus);
      if (p_nim->iostatus)
      {
         return (False);
      }
      
      ucRegVal |= 0x20;
      
      (p_nim->SBWrite)(p_nim->demod_handle, 0x23, ucRegVal, &p_nim->iostatus);
      if (p_nim->iostatus)
      {
         return (False);
      }
   }
   return (True);
}


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_RepeaterModeReadData() 
 * Sets the demod in repeater mode and reads 8-bit data.
 *******************************************************************************************************/
BOOL
HAMARO_TUNER_CX24128_RepeaterModeReadData(HAMARO_NIM* p_nim, unsigned long handle, HAMARO_SBaddress address, unsigned char* p_data_read)
{
	if (p_data_read == 0)
	{
		return (False);
	}
	if (HAMARO_TUNER_CX24128_SetDemodRepeaterMode(p_nim) == False)
	{
		return(False);
	}

	*p_data_read = (unsigned char)(TunerSBRead(handle, address, &p_nim->iostatus));

	if (p_nim->iostatus != 0UL)
	{
		/* Hardware write error */
		HAMARO_DRIVER_SET_ERROR(p_nim, HAMARO_REG_HDWR_REWTERR);
		return (False);
	}
	return(True);
}


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_RepeaterModeWriteData() 
 * Sets the demod in repeater mode and writes 8-bit data.
 *******************************************************************************************************/
BOOL
HAMARO_TUNER_CX24128_RepeaterModeWriteData(HAMARO_NIM* p_nim, unsigned long handle, HAMARO_SBaddress address, unsigned char value)
{
	if (HAMARO_TUNER_CX24128_SetDemodRepeaterMode(p_nim) == False)
	{
		return(False);
	}

	TunerSBWrite(handle, address, value, &p_nim->iostatus);

	if (p_nim->iostatus != 0UL)  
	{
		return(False);
	}

	return(True);
}


/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_EnableDemodRepeaterMode() 
 * Enables the demod's repeater
 *******************************************************************************************************/
BOOL  
HAMARO_TUNER_CX24128_EnableDemodRepeaterMode(HAMARO_NIM *p_nim)
{
       unsigned char ucRegVal;
	/* Disable BTI mode */
	ucRegVal = (p_nim->SBRead)(p_nim->demod_handle, 0x23, &p_nim->iostatus);
   	if (p_nim->iostatus)
   	{
      	return (False);
   	}
   
   	ucRegVal &= 0x7F;      
   	(p_nim->SBWrite)(p_nim->demod_handle, 0x23, ucRegVal, &p_nim->iostatus);
   	if (p_nim->iostatus)
   	{
      	return (False);
   	}
	
	if (p_nim->demod_type == HAMARO_CX2430X)
	{
		/* Set the repeater mode. */ 
		ucRegVal |= 0x40;
   		(p_nim->SBWrite)(p_nim->demod_handle, 0x23, ucRegVal, &p_nim->iostatus);
   		if (p_nim->iostatus)
   		{
      		return (False);
   		}
	}
	return(True);
}

/**************************************** Viper functions **********************************************/
/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_LockTest() 
 * Lock test.
 *******************************************************************************************************/
static BOOL 
HAMARO_TUNER_CX24128_LockTest(HAMARO_NIM *p_nim)
{
   unsigned char  reg_value = 0;
   /* Read 0x10[1] */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x10), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value &= 0x02; /* Get 0x10[1] only */
   if (reg_value == 0x02)
   {
      return (True);
   }
	            
   /* Check back again after some delay */
   HAMARO_OS_Wait (p_nim, HAMARO_VIPER_LOCK_TEST_WAIT_TIME);

    if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x10), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
	
   reg_value &= 0x02; /* Get 0x10[1] only */

   if (reg_value == 0x00)  
   {
      return (False);
   }
   else  
   {
      return (True);
   }
}

/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_WriteVCOAndBandSelect() 
 * Lock test.
 *******************************************************************************************************/
static BOOL
HAMARO_TUNER_CX24128_WriteVCOAndBandSelect(HAMARO_NIM *p_nim, unsigned long vco_and_band_sel)
{

    /* write vco_and_band_sel to 0x18[7:0] */
    if (HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x18), vco_and_band_sel, HAMARO_IO_UNKNOWN) != True)                  
    {
	    return(False);
    }
    return (True);
}



/*******************************************************************************************************
 * HAMARO_TUNER_CX24128_TuningMachineFailSafe() 
 * Tuner machine fail safe mechanism.
 *******************************************************************************************************/
static BOOL
HAMARO_TUNER_CX24128_TuningMachineFailSafe(HAMARO_NIM *p_nim)
{
   unsigned char i;
   unsigned char reg_value;
   unsigned char vco_sel;
   unsigned char vco6_sel;
   unsigned char band_sel;
   unsigned char div_24_sel;
   unsigned char reg_byte;
   if((p_nim->pll_frequency)<2146 * HAMARO_MM)
   {	
      if (HAMARO_TUNER_CX24128_LockTest(p_nim) == True) /* pll lock */
      {
         return (True);
      }
   } 
   /* read vco selection */
   if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x18), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   /* get 0x18[7] */
   vco6_sel = ((unsigned char)reg_value & 0x80);
   /* get 0x18[6] */
   div_24_sel = ((unsigned char)reg_value & 0x40);
   /* get 0x18[0] */
   band_sel = ((unsigned char)reg_value & 0x01);
   
   /* record 0x18[7] to reg_byte */
   reg_byte = vco6_sel;
   
   if (vco6_sel == 0x00)
   {
      /* get 0x18[5:1] */
      vco_sel = ((unsigned char)reg_value & 0x3E);
      reg_byte |= vco_sel; /* reg_byte = 0x18[5:1] */
   }
   
   reg_byte |= band_sel; /* reg_byte = 0x18[7] [0] */
   
   for (i = 0; i < HAMARO_MAX_VCO_SELECTIONS; i++)
   {
      if (reg_byte == vco_and_band_selection[i])
      {
         break;
      }
   }
   
   /* Switch to manual mode */
   /* write 0x14[7:6] to 1 */
    if (HAMARO_TunerRegisterRead(p_nim, (unsigned short)(0x14), (unsigned long*)&reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   reg_value &= 0x3F; /* clear ox14[7:6] */
   reg_value |= 0x40;
   if (HAMARO_TunerRegisterWrite(p_nim, (unsigned short)(0x14), (unsigned long)reg_value, HAMARO_IO_UNKNOWN) != True)  
   {
      return(False);
   }
   
   /* Attempt one VCO down */
   if (i > 0) 
   {
      reg_byte = vco_and_band_selection[i-1];
      
      if (HAMARO_TUNER_CX24128_WriteVCOAndBandSelect (p_nim, (unsigned long)(reg_byte | div_24_sel)) == False)
      {
         return (False);
      }
      
      if (HAMARO_TUNER_CX24128_LockTest(p_nim) == True) /* pll lock */
      {
         return (True);
      }
   }
   else /* i == 0 */
   {
      if (div_24_sel == 0x00) /* /2 to /4 transition */
      {
         div_24_sel = (unsigned char)0x40; 
         reg_byte = vco_and_band_selection[HAMARO_MAX_VCO_SELECTIONS-1]; // VCO6H
         
         if (HAMARO_TUNER_CX24128_WriteVCOAndBandSelect (p_nim, (unsigned long)(reg_byte | div_24_sel)) == False)
         {
            return (False);
         }
         
         if (HAMARO_TUNER_CX24128_LockTest(p_nim) == True) 
         {
            return (True);
         }
       }
   }
   
   /* attempt one VCO up */
   if (i < (HAMARO_MAX_VCO_SELECTIONS-1)) /* not end of list */
   {
      reg_byte = vco_and_band_selection[i+1];
      
      if (HAMARO_TUNER_CX24128_WriteVCOAndBandSelect (p_nim, (unsigned long)(reg_byte | div_24_sel)) == False)	
      {
         return (False);
      }
      if (HAMARO_TUNER_CX24128_LockTest(p_nim) == True) /* pll lock */
      {
         return (True);
      }
   }
   else /* i == (HAMARO_MAX_VCO_SELECTIONS-1) */
   {
      if (div_24_sel == 0x40) /* /4 to /2 transition */
      {
         div_24_sel = (unsigned char)0x00; 
         reg_byte = vco_and_band_selection[0]; // VCO1L
         
         if (HAMARO_TUNER_CX24128_WriteVCOAndBandSelect (p_nim, (unsigned long)(reg_byte | div_24_sel)) == False)
         {
            return (False);
         }
         
         if (HAMARO_TUNER_CX24128_LockTest(p_nim) == True) /* pll lock */