tvp7002.c

IT projecotr reference design.

 * for explanations of the I2C function error codes.  
 *
 * @param  void
 *
 * @return BOOL - FALSE if an underlying I2C function has not returned the I2C_CMD_LOCK_ERROR code
 *                TRUE if an underlying I2C function has returned the I2C_CMD_LOCK_ERROR code  
 */
{
	return IsI2CDead;
}
       
        
/*****************************************************************************/
/* Initialization   **********************************************************/
/*****************************************************************************/

void ADC_CfgADC(I2CPORT i2c_port, I2CINIT *i2c_cfg, uint16 i2c_address, uint08 max_sample_freq_in_mhz, uint16 cap_in_nanofarads)
/**
 * Specifies the port connected to the ADC, the ADC specific
 * I2CINIT structure, the ADC I2C address, the device's maximum 
 * sample frequency in MHz, and when applicable, the loop 
 * filter cap value in nanofarads. OEM supplied ADC drivers 
 * must implement this function.
 *
 * NOTE: This function is called by the AutoLock function, ALC_AutoLockADCInit().
 * 
 * @param  ic2_port				  - I - I2C port
 * @param *i2c_cfg                - I - configuration structure ADC device
 * @param  i2c_address            - I - I2C address of ADC.
 * @param  max_sample_freq_in_mhz - I - maximum sample frequency in MHz.
 * @param  cap_in_nanofarads      - I - loop filter cap in nanofarads
 *
 * @return void
 */
{ 
	I2CPort            =  i2c_port;
	I2CCfg             = *i2c_cfg;
    I2CAddress         =  i2c_address;
    MaxSampleFreqInMHz =  max_sample_freq_in_mhz;
    LoopFilterCapInNF  =  cap_in_nanofarads;
    NumTableEntries    =  sizeof(ADC_FunctionTable) / sizeof(ADC_TableEntryStruct);
}

int08 ADC_InitADC(void)
/**
 * This function initializes the ADC for operation with the AutoLock
 * implementation. OEM supplied ADC drivers must implement this function.
 *
 * NOTE: This function is called by the AutoLock function, ALC_AutoLockADCInit().
 * 
 * @param  void
 *
 * @return  PASS												<BR>
 * 			ADC_I2C_DRIVER_ERROR								<BR>
 * 		    ADC_I2C_DRIVER_TERMINAL_ERROR  						<BR> 
 * 			ADC_RTA_SEM_IN_USE									<BR>
 * 			ADC_RTA_ERROR
 */
{ 
	uint08 i;
	uint08 value;
	uint08 byte_array[ADC_NUM_REGISTERS + 1];
	
	NumTableEntries = sizeof(ADC_FunctionTable) / sizeof(ADC_TableEntryStruct);
	
    /* Build the initialization array */
	for (i = 0; i < NumTableEntries; i++)
	{
		if (ADC_FunctionTable[i].DoesExist)
		{
    		value = ADC_FunctionTable[i].DefaultVal;

    		if (ADC_FunctionTable[i].IsInverted) value = !value;   		

    		ADC_SetADCArrayByte(ADC_FunctionTable[i].Reg, 
    							ADC_FunctionTable[i].BitPosition, 
    							ADC_FunctionTable[i].Mask, 
    							value);
		}
	}
	    
/****************************     LOOK HERE!   *******************************/ 
/*****************************************************************************/
	
    // write this register which is not one of the standard ones
    ADC_SetADCArrayByte(0x16, 4, 0x10, 0x01);   // normal operation for chroma alignment
    ADC_SetADCArrayByte(0x17, 0, 0x02, 0x00);   // SOG out enabled    
	ADC_SetADCArrayByte(0x18, 0, 0xFF, 0x01);   // Invert dataclock output   
	ADC_SetADCArrayByte(0x1A, 4, 0x30, 0x02);   // 1.7 MHz clamp lo-pass filter
	ADC_SetADCArrayByte(0x22, 0, 0x81, 0x01);   // sync processing block enabled; 
	                                            // VSYNC processing bypassed
		
	ADC_SetADCArrayByte(0x26, 0, 0xFF, 0x80);   // ALC enable
	ADC_SetADCArrayByte(0x29, 0, 0xFF, 0x08);   // reserved
	ADC_SetADCArrayByte(0x2f, 0, 0xFF, 0x8C);   // reserved; was 80h for 7001
	ADC_SetADCArrayByte(0x30, 0, 0xFF, 0x04);   // reserved
	
	ADC_SetADCArrayByte(0x32, 0, 0xFF, 0x18);   // reserved	
	ADC_SetADCArrayByte(0x33, 0, 0xFF, 0x60);   // reserved	
	ADC_SetADCArrayByte(0x34, 0, 0xFF, 0x03);   // reserved		    	   
	ADC_SetADCArrayByte(0x3E, 0, 0xFF, 0x04);   // reserved	
	
	/* 7002 register set extends through 0x5D */
	
	byte_array[0] = 1;

	/* set up to write to registers sequentially */
	for (i = 1; i <= ADC_NUM_REGISTERS; i++)
	{
		byte_array[i] = ADC_Registers[i];
	}
    
 	return ADC_Write (ADC_NUM_REGISTERS + 1, byte_array); 
}

                              
/*****************************************************************************/
/* Software Revision  ********************************************************/
/*****************************************************************************/

int08 ADC_GetSoftwareRevision(uint08 *sw_rev)
/**
 * Gets the ADC software revision.
 *  
 * @param  *sw_rev - I - storage for software revision
 *
 * @return PASS													<BR>
 *		   ADC_FUNCTION_NOT_SUPPORTED							<BR>
 *		   ADC_I2C_DRIVER_ERROR									<BR>
 *		   ADC_RTA_SEM_IN_USE									<BR>
 *		   ADC_RTA_ERROR
 */
{ 		
    return ADC_GetADCByte(ADC_CHIP_REVISION, sw_rev);       
}

/*****************************************************************************/
/* Firmware Revision  ********************************************************/
/*****************************************************************************/

int08 ADC_GetFirmwareRevision(uint08 *fw_rev)
/**
 * Gets the ADC firmware revision.
 *
 * @param  *fw_rev - I - storage for firmware revision
 *
 * @return PASS													<BR>
 *		   ADC_FUNCTION_NOT_SUPPORTED							<BR>
 *		   ADC_I2C_DRIVER_ERROR									<BR>
 *		   ADC_RTA_SEM_IN_USE									<BR>
 *		   ADC_RTA_ERROR
 */
{   
	return ADC_GetADCByte(ADC_CHIP_REVISION, fw_rev);      
}

/*****************************************************************************/
/* PLL Divider Control  ******************************************************/
/*****************************************************************************/

int08 ADC_SetPLLDivider(uint16 pll_divide_ratio)
/**
 * Sets the ADC PLL divide ratio.
 *
 * The PLL divide ratio divides the HSYNC input frequency to create the
 * sampling clock.
 *
 * @param  pll_divide_ratio - I - PLL divide ratio value.
 *
 * @return PASS													<BR>
 *   	   ADC_FIELD_LIMITS_UNSPECIFIED							<BR>
 *         ADC_I2C_DRIVER_ERROR									<BR>
 * 		   ADC_I2C_DRIVER_TERMINAL_ERROR  						<BR> 
 *         ADC_RTA_SEM_IN_USE									<BR> 
 *         ADC_RTA_ERROR	 	   		    
 */    
{
	int08  status;
	uint08 data[3];
	ADC_FieldLimitsStruct field_limits;

    status = ADC_GetLimits(ADC_PLL_LIMITS, &field_limits);
    
	if (status != PASS) return status;
	
	if (pll_divide_ratio > field_limits.Limits.UpperLimit)
	{
		pll_divide_ratio = field_limits.Limits.UpperLimit;
	}	
	else if (pll_divide_ratio < field_limits.Limits.LowerLimit)	
	{
		pll_divide_ratio = field_limits.Limits.LowerLimit;
	}
	
	data[0] = (uint08)ADC_PLL_DIVIDER_MSB_REG;
	data[1] = (uint08)((pll_divide_ratio >> 4) & 0x00ff);
	data[2] = (uint08)((pll_divide_ratio << 4) & 0x00f0);

	return ADC_Write(3, data);
}

int08 ADC_GetPLLDivider(uint16 *pll_divide_ratio)
/**
 * Gets the ADC PLL divide ratio.
 *
 * NOTE:														<BR>
 * This function is called by the AutoLock API, ALC_GetSampleClock(). 
 * OEM supplied ADC drivers must implement this function.
 * 
 * @param  *pll_divide_ratio - I - storage for PLL divide ratio value.
 *
 * @return PASS														<BR>
 *		   ADC_I2C_DRIVER_ERROR										<BR>
 * 		   ADC_I2C_DRIVER_TERMINAL_ERROR  							<BR>
 *		   ADC_RTA_SEM_IN_USE										<BR>
 *		   ADC_RTA_ERROR
 */
{   
	int08  status;
    uint08 data[2];
      
    status = ADC_Read((uint08)ADC_PLL_DIVIDER_MSB_REG, 2, data);
    if (status == PASS)
    {
    	*pll_divide_ratio = (((uint16)data[0] << 4) | ((uint16)data[1] >> 4)) - 1;
    }
    return status;	
}

int08 ADC_GetPLLLimits(ADC_LimitStruct *limits)
/**
 * This function gets the allowable range of the PLL divide ratio 
 * register settings as specified by the ADC's data sheet. This is 
 * not the "samples per second" rating.
 *
 * NOTE: 															<BR>
 * This function is called by the AutoLock function. It is used
 * to ensure the calculated sample clock value does not exceed the
 * range allowed by the ADC. OEM supplied ADC drivers must implement 
 * this function. 
 *
 * @param  *limits - I - pointer to struct containing limit values.
 *
 * @return PASS														<BR>
 *         ADC_FIELD_LIMITS_UNSPECIFIED
 */    
{ 
	int08 status;
	ADC_FieldLimitsStruct field_limits;

    status = ADC_GetLimits(ADC_PLL_LIMITS, &field_limits);
    if (status == PASS) *limits = field_limits.Limits;
    return status;
}

/*****************************************************************************/
/* Input Gain & Offset Control  **********************************************/
/*****************************************************************************/

int08 ADC_SetGain(uint16 red, uint16 green, uint16 blue)
/**
 * Sets the ADC gain adjustment.
 *
 * NOTE:														<BR>
 * This function is called by the AutoLock API, ALC_SetGain(). 
 * OEM supplied ADC drivers must implement this function.
 * For the devices supported by this driver, the input gain 
 * values are subtracted from the maximum register setting 
 * before application to the ADC. Hence the reference to
 * non-inverted values. 
 *
 * @param  red   - I - non-inverted value of red gain
 * @param  green - I - non-inverted value of green gain
 * @param  blue  - I - non-inverted value of blue gain
 *
 * @return PASS													<BR>
 *   	   ADC_FIELD_LIMITS_UNSPECIFIED							<BR>
 *         ADC_VALUE_OOR_MIN									<BR>
 *         ADC_VALUE_OOR_MAX									<BR>
 *         ADC_I2C_DRIVER_ERROR									<BR>
 * 		   ADC_I2C_DRIVER_TERMINAL_ERROR  						<BR> 
 *         ADC_RTA_SEM_IN_USE									<BR> 
 *         ADC_RTA_ERROR	 	   		    
 */
{     
 	int08 status;
    uint08 data[4];
 	ADC_FieldLimitsStruct field_limits;      

	status = ADC_GetLimits(ADC_GAIN_LIMITS, &field_limits);
	if (status != PASS) return status;

    if (red   > field_limits.Limits.UpperLimit) return ADC_VALUE_OOR_MAX;
    if (red   < field_limits.Limits.LowerLimit) return ADC_VALUE_OOR_MIN;
    if (green > field_limits.Limits.UpperLimit) return ADC_VALUE_OOR_MAX;
    if (green < field_limits.Limits.LowerLimit) return ADC_VALUE_OOR_MIN;
    if (blue  > field_limits.Limits.UpperLimit) return ADC_VALUE_OOR_MAX;
    if (blue  < field_limits.Limits.LowerLimit) return ADC_VALUE_OOR_MIN;
	
	data[0] = (uint08)ADC_BLUE_GAIN_REG;
    data[1] = (uint08)blue;
    data[2] = (uint08)green;
    data[3] = (uint08)red;
    	    
	return ADC_Write (4, data);
}

int08 ADC_GetGain(uint16 *red, uint16 *green, uint16 *blue)
/**
 * Gets the ADC gain adjustment value.
 *
 * NOTE:														<BR>
 * This function is called by the AutoLock API, ALC_GetGain(). 
 * OEM supplied ADC drivers must implement this function.
 * For the devices supported by this driver, the address 
 * arguments are populated with the maximum register values 
 * minus the values read from the ADC. Hence the reference 
 * to non-inverted values.
 *
 * @param  *red   - I - storage for non-inverted value of red gain
 * @param  *green - I - storage for non-inverted value of green gain
 * @param  *blue  - I - storage for non-inverted value of blue gain
 *
 * @return PASS													<BR>
 *   	   ADC_FIELD_LIMITS_UNSPECIFIED							<BR>
 *		   ADC_I2C_DRIVER_ERROR									<BR>
 * 		   ADC_I2C_DRIVER_TERMINAL_ERROR  						<BR> 
 *		   ADC_RTA_SEM_IN_USE									<BR>
 *		   ADC_RTA_ERROR
 */
{ 
 	int08 status;
    uint08 data[3];
 	ADC_FieldLimitsStruct field_limits;      

	status = ADC_GetLimits(ADC_GAIN_LIMITS, &field_limits);
	if (status != PASS) return status;