sad9888.c

Ad9888.c analog公司VGA/DVI AD芯片源码

/*------------------------------------------------------------------------
--  Copyright 2003 by Silicon Optix Inc.  All rights reserved. 
--
--  This document contains proprietary and confidential information of
--  Silicon Optix Inc. Distribution, copying, disclosure, or incorporation
--  in other material in whole, in part, or modified form is strictly 
--  prohibited without written permission from Silicon Optix Inc. 
--  Use of this information must be in accordance with the Silicon Optix
--  Software Licensing Agreement. If this information is received in error, 
--  please delete and notify us immediately.
--
------------------------------------------------------------------------
-- File Name  : sADV9888.c
-- Purpose    : API functions for ADV9888
--            :
------------------------------------------------------------------------
-- Revision History:
------------------------------------------------------------------------
-- <See $Log at end for detailed CVS history>
-- 
-- Creator's Name : Dennis Lam
-- Creation Date  : Nov. 20, 2003
-- Comment        : Initial Release
--
-- Revision   : 
-- Name       : 
-- Date       :
-- Comment    :
--                                                                   
*-------------------------------------------------------------------------
*/

#define SADV9888_C
/****************************************************************************/
/*  I N C L U D E    F I L E S                                                       */
/****************************************************************************/

#include "main/aConfig.h"
#include "main/aGlobal.h"
#ifdef uI_NUCLEUS
#include	"nucleus.h"
#include	"Tc_defs.h"
#endif
#include "sd_defs.h"
#include "sd_extr.h"
#include "main/uItron/uI_types.h"
#include "main/uItron/uI_setm.h"
#include "main/uItron/uI_nplus.h"
#include "main/aInit.h"

#include "Driver.h"
#include "Driver/adc/dadc.h"
#include "Driver/common/aDrvTsk.h"
#include "Driver/i2c/dI2c.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Image/Detect/sMode.h"
#include "Image/Detect/sPort.h"
#include "Image/Detect/sDetect.h"
#include "sAd9888.h"

#if ADC_OPTION ==ADC_9888 || ADC2_OPTION ==ADC_9888
BYTE byWriteSingleDataAdv9888(BYTE by_reg_address, BYTE by_data)
{
	tst_ADC_WRITE_CONFIG st_adc_write_config;

#ifdef Use_DRV_NONBLOCKING_OPTION
	st_adc_write_config.t_blocking = BLOCKING;
#endif
	st_adc_write_config.t_change_priority = PRI_NO_CHANGE;
	st_adc_write_config.u32_delay = 0;
	st_adc_write_config.u32_max_count = 1;
	st_adc_write_config.u32_reg_address = by_reg_address;
	st_adc_write_config.u32_length = 1;
#if ADC_OPTION ==ADC_9888
	return st_adc_driver.Write(&by_data, &st_adc_write_config, &st_adc_driver);
#elif ADC2_OPTION ==ADC_9888
	return st_adc2_driver.Write(&by_data, &st_adc_write_config, &st_adc_driver);
#endif

}

BYTE byReadSingleDataAdv9888(BYTE by_reg_address, BYTE *byp_data)
{
	tst_ADC_READ_CONFIG st_adc_read_config;

#ifdef Use_DRV_NONBLOCKING_OPTION
	st_adc_read_config.t_blocking = BLOCKING;
#endif
	st_adc_read_config.t_change_priority = PRI_NO_CHANGE;
	st_adc_read_config.u32_delay = 0;
	st_adc_read_config.u32_max_count = 1;
	st_adc_read_config.u32_reg_address = by_reg_address;
	st_adc_read_config.u32_length = 1;
#if ADC_OPTION ==ADC_9888
	return st_adc_driver.Read(byp_data, &st_adc_read_config, &st_adc_driver);
#elif ADC2_OPTION ==ADC_9888
	return st_adc2_driver.Read(byp_data, &st_adc_read_config, &st_adc_driver);
#endif
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////
//ADV9888
///////////////////////////////////////////////////////////////////////////////////////////////////////////
BYTE byAdv9888Init(UWORD32 u32_port_id)
{
	BYTE by_ret=OK;
	BYTE by_count=0;

	for (by_count=0;by_count < AD9888_RGB_INIT_REG_MAX;by_count +=2)
	{
		by_ret |=byWriteSingleDataAdv9888(bya_ad9888_init[by_count], bya_ad9888_init[by_count+1]); 
	}
	return by_ret;
}

BYTE byAdv9888Input_mux(UWORD32 u32_port_id, BYTE by_input_mux)
{
	BYTE by_data;
	
	// switch between Input1 and Input2 on Adv9888
	byReadSingleDataAdv9888(AD9888_INPUT_OUTPUT_CONTROL, &by_data);
	by_data &= 0xF7;
	by_data |= (by_input_mux<<3);
	byWriteSingleDataAdv9888(AD9888_INPUT_OUTPUT_CONTROL, by_data);
	return OK;
}

BYTE byAdv9888InitMsr(UWORD32 u32_port_id)
{
	u32_ifm_msr_tmr[u32_port_id]=10;
	return OK;
}

BYTE byAdv9888GetInitMsrDone(UWORD32 u32_port_id, UWORD32 *u32p_init_done)
{
	if(u32_ifm_msr_tmr[u32_port_id] == 0)
		*u32p_init_done = 1;
	else
		*u32p_init_done = 0;
	return OK;
}

BYTE byAdv9888StartMsr(UWORD32 u32_port_id)
{
	u32_ifm_msr_tmr[u32_port_id] =10;
	return OK;
}

BYTE byAdv9888GetMsrDone(UWORD32 u32_port_id, UWORD32 *u32p_msr_done)
{
	*u32p_msr_done = 1;
	return OK;
}

BYTE byAdv9888GetMsrRaw(UWORD32 u32_port_id, st_RAW_MSR *stp_raw_msr )
{
	BYTE by_data;

	byReadSingleDataAdv9888(AD9888_SYNC_DETECT, &by_data);
	if((by_data & AD9888_S_DET_VS_DET) && (by_data & AD9888_S_DET_HS_DET))
	{
		stp_raw_msr->u32_inp_setup |= VALID_DSS;
		stp_raw_msr->u32_inp_setup &=  (~VALID_DCS);
		stp_raw_msr->u32_inp_setup &=  (~VALID_ACS);
	}
	else if(!(by_data & AD9888_S_DET_VS_DET) && (by_data & AD9888_S_DET_HS_DET))
	{
		stp_raw_msr->u32_inp_setup |= VALID_DCS;
		stp_raw_msr->u32_inp_setup &=  (~VALID_DSS);
		stp_raw_msr->u32_inp_setup &=  (~VALID_ACS);
	}
	else if(by_data & AD9888_S_DET_SOG_DET)
	{
		stp_raw_msr->u32_inp_setup |= VALID_ACS;
		stp_raw_msr->u32_inp_setup &=  (~VALID_DSS);
		stp_raw_msr->u32_inp_setup &=  (~VALID_DCS);
	}
	else
	{
		stp_raw_msr->u32_inp_setup &=  (~VALID_ACS);
		stp_raw_msr->u32_inp_setup &=  (~VALID_DSS);
		stp_raw_msr->u32_inp_setup &=  (~VALID_DCS);
	}

	stp_raw_msr->u32_valid_var |= (VALID_DSS | VALID_DCS | VALID_ACS);
	return OK;
	
}

BYTE byAdv9888SetMode(UWORD32 u32_port_id, BYTE *byp_table)
{//Mode configure
	BYTE by_ret=OK;
	BYTE by_count=0;

	for (by_count=0;by_count < AD9888_RGB_MODE_REG_MAX;by_count +=2)
	{
		by_ret |=byWriteSingleDataAdv9888(byp_table[by_count], byp_table[by_count+1]); 
	}
	return by_ret;
}

BYTE byAdv9888SetInpSetup(UWORD32 u32_port_id)
{// Hsync & Vsync polarity configure
	UWORD32 u32_setup;
	BYTE by_sync_dtct;
	BYTE by_sync_ctrl = 0x16;

	return OK;

}

BYTE byAdv9888SetBright (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;

	by_ret |=byAdv9888SetRedOffset(u32_port_id, u32_value);  
	by_ret |=byAdv9888SetGreenOffset(u32_port_id, u32_value);  
	by_ret |=byAdv9888SetBlueOffset(u32_port_id, u32_value);  
	return by_ret;
}

BYTE byAdv9888SetContrast (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;

	by_ret |=byAdv9888SetRedGain(u32_port_id, u32_value);  
	by_ret |=byAdv9888SetGreenGain(u32_port_id, u32_value);  
	by_ret |=byAdv9888SetBlueGain(u32_port_id, u32_value);  
	return by_ret;
}

BYTE byAdv9888SetRedGain (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_RED_GAIN, by_data);  
	return by_ret;
}

BYTE byAdv9888SetGreenGain (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_GREEN_GAIN, by_data);  
	return by_ret;
}

BYTE byAdv9888SetBlueGain (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_BLUE_GAIN, by_data);  
	return by_ret;
}

BYTE byAdv9888SetRedOffset (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_RED_OFFSET, (by_data<<1));  
	return by_ret;
}

BYTE byAdv9888SetGreenOffset (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_GREEN_OFFSET, (by_data<<1));  
	return by_ret;
}

BYTE byAdv9888SetBlueOffset (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (WORD)(u32_value);

	by_ret |=byWriteSingleDataAdv9888(AD9888_BLUE_OFFSET, (by_data<<1));  
	return by_ret;
}

BYTE byAdv9888SetClock (UWORD32 u32_port_id, UWORD32 u32_value)
{
 	BYTE by_ret=OK;
 	WORD w_data;

	w_data = (WORD)((u32_value - 1)<<4);

	by_ret  |=byWriteSingleDataAdv9888(AD9888_PLL_DIV_MSB, (BYTE)(w_data>>8));  
	by_ret  |=byWriteSingleDataAdv9888(AD9888_PLL_DIV_LSB, (BYTE)(w_data));  

	return by_ret;
}

BYTE byAdv9888SetPhase (UWORD32 u32_port_id, UWORD32 u32_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_data = (BYTE)(u32_value);
	by_ret |=byWriteSingleDataAdv9888(AD9888_PHASE_ADJUST, by_data);  
	return by_ret;
}

BYTE byAdv9888GetBright (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;

	by_ret |=byAdv9888GetRedOffset(u32_port_id, u32p_value);  
	return by_ret;
}

BYTE byAdv9888GetContrast (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;

	by_ret |=byAdv9888GetRedGain(u32_port_id, u32p_value);  
	return by_ret;
}

BYTE byAdv9888GetRedGain (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_RED_GAIN, &by_data);  
	*u32p_value = (WORD)(by_data);
	return by_ret;
}

BYTE byAdv9888GetGreenGain (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_GREEN_GAIN, &by_data);  
	*u32p_value = (WORD)(by_data);
	return by_ret;
}

BYTE byAdv9888GetBlueGain (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_BLUE_GAIN, &by_data);  
	*u32p_value = (WORD)(by_data);
	return by_ret;
}

BYTE byAdv9888GetRedOffset (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_RED_OFFSET, &by_data);  
	*u32p_value = (WORD)(by_data>>1);
	return by_ret;
}

BYTE byAdv9888GetGreenOffset (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_GREEN_OFFSET, &by_data);  
	*u32p_value = (WORD)(by_data>>1);
	return by_ret;
}

BYTE byAdv9888GetBlueOffset (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_BLUE_OFFSET, &by_data);  
	*u32p_value = (WORD)(by_data>>1);
	return by_ret;
}


BYTE byAdv9888GetClock (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
 	BYTE by_ret=OK;
	BYTE by_data;
 	WORD w_data=0;

	by_ret  |=byReadSingleDataAdv9888(AD9888_PLL_DIV_MSB, &by_data);  
	w_data |= (WORD)(by_data<<4);
	by_ret  |=byReadSingleDataAdv9888(AD9888_PLL_DIV_LSB, &by_data);  
	w_data |= (WORD)(by_data>>4);

	*u32p_value = w_data + 1;
	
	return by_ret;
}

BYTE byAdv9888GetPhase (UWORD32 u32_port_id, UWORD32 *u32p_value)
{
	BYTE by_ret=OK;
	BYTE by_data;

	by_ret |=byReadSingleDataAdv9888(AD9888_PHASE_ADJUST, &by_data);  
	*u32p_value = (UWORD32)(by_data>>3);
	return by_ret;
}

BYTE byAdv9888GetBrightInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_BRIGHTNESS_MID);
	*ip_max = (int)( AD9888_RGB_BRIGHTNESS_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_BRIGHTNESS_MID);
	return OK;
}

BYTE byAdv9888GetContrastInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_CONTRAST_MID);
	*ip_max = (int)( AD9888_RGB_CONTRAST_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_CONTRAST_MID);
	return OK;
}

BYTE byAdv9888GetRedGainInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_RED_GAIN_MID);
	*ip_max = (int)( AD9888_RGB_RED_GAIN_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_RED_GAIN_MID);
	return OK;
}

BYTE byAdv9888GetGreenGainInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_GREEN_GAIN_MID);
	*ip_max = (int)( AD9888_RGB_GREEN_GAIN_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_GREEN_GAIN_MID);
	return OK;
}

BYTE byAdv9888GetBlueGainInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_BLUE_GAIN_MID);
	*ip_max = (int)( AD9888_RGB_BLUE_GAIN_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_BLUE_GAIN_MID);
	return OK;
}

BYTE byAdv9888GetRedOffsetInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_RED_OFFSET_MID);
	*ip_max = (int)( AD9888_RGB_RED_OFFSET_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_RED_OFFSET_MID);
	return OK;
}

BYTE byAdv9888GetGreenOffsetInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_GREEN_OFFSET_MID);
	*ip_max = (int)( AD9888_RGB_GREEN_OFFSET_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_GREEN_OFFSET_MID);
	return OK;
}

BYTE byAdv9888GetBlueOffsetInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_BLUE_OFFSET_MID);
	*ip_max = (int)( AD9888_RGB_BLUE_OFFSET_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_BLUE_OFFSET_MID);
	return OK;
}

BYTE byAdv9888GetClockInfo (UWORD32 u32_port_id, int *ip_min,int *ip_max, UWORD32 *u32p_nominal)
{

	st_MODE_TMG_INFO *stp_mode;
	BYTE by_ret=OK;
	UWORD32 u32_md_unknown, u32_inp_setup;
	
	by_ret |= PortGetInpMode(u32_port_id, &stp_mode, &u32_md_unknown, &u32_inp_setup);
	*u32p_nominal = (UWORD32) stp_mode->s32a_mode_param[MDI_H_TOT_PIX];

	*ip_min = (int) ((*u32p_nominal)-AD9888_RGB_CLOCK_MIN);
	*ip_max = (int) ((*u32p_nominal)+AD9888_RGB_CLOCK_MAX);

	return by_ret;
}

BYTE byAdv9888GetPhaseInfo (UWORD32 u32_port_id, int *ip_min, int *ip_max, UWORD32 *u32p_nominal)
{
	*ip_min = (int)( AD9888_RGB_PHASE_MIN);
	*ip_max = (int)( AD9888_RGB_PHASE_MAX);
	*u32p_nominal = (UWORD32)(AD9888_RGB_PHASE_MID);
	return OK;
}

#endif //ADC_OPTION ==ADC_9888 || ADC2_OPTION ==ADC_9888
#undef SADV9888_C

/*
 ****************************************
 * $Log: aAd9888.c,v $
 * Revision 1.1  2003/11/20 19:02:03  dennis
 ****************************************
 */