//----------------------------------------------------------------------------------------------------
// ID Code      : Eeprom.c No.0002
// Update Note  :
//
//----------------------------------------------------------------------------------------------------

#define __EEPROM__

#include "Core\Header\Include.h"


/**
* CEepromStartupCheck
* Eeprom check, if version is changed, load default value; else load all data
* @param <none>
* @return {none}
*
*/
void CEepromWriteVersion(void)
{
	pData[0] = _VERSION_CODE;
	pData[1] = _RELEASE_CODE;
	CEepromWrite(_VERSION_ADDRESS, 2, pData);
}


void CEepromStartupCheckHook(void)
{
	//audio on while power on
	if (GET_AUDIO_MUTE())
	{
		CLR_AUDIO_MUTE();
		CEepromSaveAudioData();
	}

#if 1
	if (GET_LANGUAGE()>_LANGUAGE_LAST) 
	{
		SET_LANGUAGE(_LANGUAGE_DEFAULT);
		CEepromSaveOsdUserData();
	}
#endif

#if 0//(_OSD_TIMEROUT_M2)
	if (GET_OSDTIMEOUT_OPTION()>=_TIMER_TIMEOUT_MODE_MAX)
	{
		SET_OSDTIMEOUT_OPTION(3);	//10s
		CEepromSaveOsdUserData();
	}
#endif

#if 0//(_DISP_RATIO_M2_SUPPORT)
	if (GET_DISPLAYRATIO()>_DISP_RATIO_MAX)
	{
		SET_DISPLAYRATIO(_RATIO_AUTO);
		CEepromSaveSystemData();
	}

#endif

#if 0//(_DEMO_MODE_SUPPORT)
	if (GET_DEMO_MODE())	//disable demo mode while cold power up
	{
		SET_DEMO_MODE(0);
		CEepromSaveSystemData();
	}
#endif

#if 0//(_OSD_DOUBLE_SUPPORT==0)
	if (GET_OSDDOUBLE())
	{
		SET_OSDDOUBLE(0);
		CEepromSaveOsdUserData();
	}
#endif

#if 0
	//20070409, disable time active setting while power on
	if (stTimeData.ucTimeActiveType!=0)	//active settting is not disable
	{
		stTimeData.ucTimeActiveType = 0;
		CEepromSaveTimeData();
	}
#endif

	if (stSystemData.InputSource>=_INPUT_PORT_MAX)
	{
		stSystemData.InputSource = 0;
		CEepromSaveSystemData();
	}
	
#if _TIMER_SLEEP_HINT_SUPPORT
	stTimeData = tEEPROM_TIME_DATA;
#endif	//#if _TIMER_SLEEP_HINT_SUPPORT
}


void CEepromStartupCheck(void)
{
	BYTE cnt;

#if(_MCU_TYPE == _REALTEK_RTD2662_EMCU)
	//This delay is for Eeprom power rising time when the connector plug in (VGA_5V or DVI_5V).
	CTimerDelayXms(20); 
#endif

	for(cnt=0;cnt<5;cnt++) 
	{
		CEepromRead(_VERSION_ADDRESS, 2, pData);
		if((pData[0] == _VERSION_CODE)&&( pData[1] == _RELEASE_CODE))
			break;
		CTimerDelayXms(100);
	}
	
	if ((pData[0] != _VERSION_CODE)||(pData[1] != _RELEASE_CODE))
	{
		CEepromLoadDefault();
		CEepromLoadYPbPrDataDefault();    //add  lbh 20090924
		CEepromWriteVersion();
	}
	else
	{
		CEepromLoadSystemData();
		CEepromLoadOsdUserData();
		CEepromLoadAdcData();
		
		CEepromLoadYPbPrData();

#if _SHARPNESS_REWRITE
		//20080213
		CEepromLoadPeakingCoringData();
#endif	//#if _SHARPNESS_REWRITE

#if (_PICT_EFFECT_SUPPORT)
		CEepromLoadPictModeData();
#endif
		CEepromLoadBriConData();

#if _BACKLIGHT_SUPPORT
		CEepromLoadBacklightData();
#endif

#if (_CT_INDEPENDENT_SUPPORT)
		CEepromLoadColorTempModeData();
#endif


		CEepromLoadColorTempData();
		CEepromLoadCustomerData();
		CEepromLoadTvData();	
		CEepromLoadHueSatData();
		CEepromLoadAudioData();
//20080421, DDC support for VGA. start...
		CEepromLoadFlashEdidData();
//20080421, DDC support for VGA. end...

//20080421, DDC support for digital port 0. start...
#if _HDMI_EDID_RW
		CEepromLoadFlashEdidHdmiData();
#endif  // #if _HDMI_EDID_RW
//20080421, DDC support for digital port 0. end...
		//DebugPrintf("old EEPROM\n", 0);
		CEepromLoadTimeData();
    }

	CEepromStartupCheckHook();
	
}

//--------------------------------------------------
// Description  : Load eeprom default
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadDefault(void)
{
    StructModeUserFIFODataType stFIFOModeTemp;

    if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
    {
		CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);
		stFIFOModeTemp.ModeNum = pData[(stModeInfo.ModeCurr % 4) * 4];
    }

	CEepromInitialModeData();
	CEepromInitialUserFIFOModeData();
	//20081027 ccy cancel init centermodedata
	#if _CUSTOMER_TOLIP
	#else
	CEepromInitialCenterModeData();
	#endif
	CEepromLoadSystemDataDefault();
	CEepromLoadOsdUserDataDefault();
	CEepromLoadAdcDataDefault();
	//CEepromLoadYPbPrDataDefault();	//no change for YPBPR ADC data in factory reset   lbh 20090924			
#if (_PICT_EFFECT_SUPPORT)
	CEepromLoadPictModeDataDefault();
#endif
#if _SHARPNESS_REWRITE
	//20080213
	CEepromLoadPeakingCoringDataDefault();
#endif	//#if _SHARPNESS_REWRITE

#if (_CT_INDEPENDENT_SUPPORT)
	CEepromLoadColorTempModeDataDefault();
#endif
#if _BACKLIGHT_SUPPORT
	CEepromLoadBacklightDataDefault();
#endif

	CEepromLoadBriConDataDefault();
	CEepromLoadColorTempDataDefault();
	CEepromLoadCustomerDefaultData();
	CEepromLoadTvDataDefault();
	CEepromLoadHueSatDataDefault();
	CEepromLoadAudioDataDefault();
//20080421, DDC support for VGA. start...
	CEepromLoadFlashEdidDataDefault();
//20080421, DDC support for VGA. end...

	CEepromLoadTimeDataDefault();
    if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
    {
      	if(stSystemData.UserFIFOMode >= 15)
           	stSystemData.UserFIFOMode = 0;
        else
           	stSystemData.UserFIFOMode++;

        stFIFOModeTemp.IHFreq  = stModeInfo.IHFreq;
        stFIFOModeTemp.IVFreq  = stModeInfo.IVFreq;
        CEepromSaveUserFIFOModeData(stFIFOModeTemp);

        stModeUserData.FirstAuto    = 0;
        //stModeUserData.HPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHStartPos;
        //stModeUserData.VPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IVStartPos;
        //stModeUserData.Clock        = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHTotal;
	 stModeUserData.HPosition    = CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IHStartPos);
        stModeUserData.VPosition    = CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IVStartPos);
        stModeUserData.Clock        = CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IHTotal);
        stModeUserData.Phase        = 0;
        CEepromSaveModeData(stSystemData.UserFIFOMode);
        stModeInfo.ModeCurr = stSystemData.UserFIFOMode;
    }
    else if((GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE) && (stModeInfo.ModeCurr < _MAX_PRESET_MODE))
    {
        CEepromLoadModeData(stModeInfo.ModeCurr);
    }

	CEepromInitialModeDataYPbPr();
}

//premier
//--------------------------------------------------
// Description  : Load eeprom default
// Input Value  : 
// Output Value : None
//--------------------------------------------------
void CEepromLoadDefaultSource(void)                   //modified by xyw 070814
{
#if 0
//////////////////////////////////////////////////////
    StructModeUserFIFODataType stFIFOModeTemp;

    if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
    {
		CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);
		stFIFOModeTemp.ModeNum = pData[(stModeInfo.ModeCurr % 4) * 4];
    }


	switch (GET_INPUTPORT_TYPE(stSystemData.InputSource))
	{
		case _DSUB_A0_PORT:
#if (_HDMI_SUPPORT)
		case _HDMI_PORT:
		case _HDMI_PORT2:
#endif
		case _DVI_I_A0_PORT:

                 if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
			{
				CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);
				stFIFOModeTemp.ModeNum = pData[(stModeInfo.ModeCurr % 4) * 4];
			}

			CEepromInitialModeData();
			CEepromInitialUserFIFOModeData();
			CEepromInitialCenterModeData();

                     //reset color temp of user
			SET_COLOR_TEMP_TYPE(_CT_USER);
		 //if(GET_INPUTPORT_TYPE(stSystemData.InputSource)==_DSUB_A0_PORT)
		 	//{
			//stColorTempData.ColorTemp[_RED]=tEEPROM_COLORTEMP_DATA[_SOURCE_VGA].ColorTempUserRed;
			//stColorTempData.ColorTemp[_GREEN]=tEEPROM_COLORTEMP_DATA[_SOURCE_VGA].ColorTempUserRed;
			//stColorTempData.ColorTemp[_BLUE]=tEEPROM_COLORTEMP_DATA[_SOURCE_VGA].ColorTempUserRed;
		 	//}
		 //else
		 	 //{
                    // stColorTempData.ColorTemp[_RED]=tEEPROM_COLORTEMP_DATA[_SOURCE_DVI].ColorTempUserRed;
			//stColorTempData.ColorTemp[_GREEN]=tEEPROM_COLORTEMP_DATA[_SOURCE_DVI].ColorTempUserRed;
			//stColorTempData.ColorTemp[_BLUE]=tEEPROM_COLORTEMP_DATA[_SOURCE_DVI].ColorTempUserRed;
		        //}
			//CEepromSaveColorTempData();
			
			

                    //CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xe0);//xyw
			stSystemData.ColorTemp = tEEPROM_SYSTEM_DATA.ColorTemp;
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.UserFIFOMode = tEEPROM_SYSTEM_DATA.UserFIFOMode;
			//stSystemData.Contrast = tEEPROM_SYSTEM_DATA.Contrast;
			//stSystemData.Brightness = tEEPROM_SYSTEM_DATA.Brightness;
			stSystemData.Gamma = (tEEPROM_SYSTEM_DATA.Gamma&0x7f);		
			stSystemData.Mode= tEEPROM_SYSTEM_DATA.Mode;
			CEepromSaveSystemData();

                   //CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			//stOsdUserData.Volumn = tEEPROM_OSDUSER_DATA.Volumn;
			CEepromSaveOsdUserData();

		
	//CEepromLoadAdcDataDefault();
	//CEepromLoadYPbPrDataDefault();
	//CEepromLoadBriConDataDefault();
                     stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[0].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[0].Contrast;
                     CEepromSaveBriConData();
	
	              CEepromLoadColorTempDataDefault();				   
	              CEepromLoadCustomerDefaultData();
	              CEepromLoadAudioDataDefault();
			#if (_PICT_EFFECT_SUPPORT)
	               CEepromLoadPictModeDataDefault();
                     #endif
			#if (_CT_INDEPENDENT_SUPPORT)
	              CEepromLoadColorTempModeDataDefault();
                     #endif


    		   if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
    		   {
      			if(stSystemData.UserFIFOMode >= 15)
           		stSystemData.UserFIFOMode = 0;
		        else
		           	stSystemData.UserFIFOMode++;

		        stFIFOModeTemp.IHFreq  = stModeInfo.IHFreq;
		        stFIFOModeTemp.IVFreq  = stModeInfo.IVFreq;
		        CEepromSaveUserFIFOModeData(stFIFOModeTemp);

		        stModeUserData.FirstAuto    = 0;
		        stModeUserData.HPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHStartPos;
		        stModeUserData.VPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IVStartPos;
		        stModeUserData.Clock        = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHTotal;
		        stModeUserData.Phase        = 0;
		        CEepromSaveModeData(stSystemData.UserFIFOMode);
		        stModeInfo.ModeCurr = stSystemData.UserFIFOMode;
		    }
		    else if((GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE) && (stModeInfo.ModeCurr < _MAX_PRESET_MODE))
		    {
		        CEepromLoadModeData(stModeInfo.ModeCurr);
		    }
					

              break;

			  
		case _VIDEO_AV_PORT:
		case _VIDEO_SV_PORT:

			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xe0);//xyw
			stSystemData.ColorTemp =tEEPROM_SYSTEM_DATA.ColorTemp;
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.ucColorSetting = tEEPROM_SYSTEM_DATA.ucColorSetting;

			stSystemData.Mode = tEEPROM_SYSTEM_DATA.Mode;
			CEepromSaveSystemData();
			
			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			//stOsdUserData.Volumn = tEEPROM_OSDUSER_DATA.Volumn;
			CEepromSaveOsdUserData();
			
			//CEepromLoadAdcDataDefault();
			
			//CEepromLoadYPbPrDataDefault();
			
			//CEepromLoadBriConDataDefault();
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[2].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[2].Contrast;
			CEepromSaveBriConData();
			
			CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			
			//CEepromLoadTvDataDefault();
			
			CEepromLoadAudioDataDefault();	
			#if (_PICT_EFFECT_SUPPORT)
	               CEepromLoadPictModeDataDefault();
                     #endif
			#if (_CT_INDEPENDENT_SUPPORT)
	              CEepromLoadColorTempModeDataDefault();
                     #endif

			CEepromLoadHueSatDataDefault();


		break;


		case _YPBPR_A0_PORT:

			
			//CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xe0);//xyw
			stSystemData.ColorTemp = stSystemData.ColorTemp&0x0f;
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;

			stSystemData.Mode = tEEPROM_SYSTEM_DATA.Mode;
			CEepromSaveSystemData();
			
			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			//stOsdUserData.Volumn = tEEPROM_OSDUSER_DATA.Volumn;
			CEepromSaveOsdUserData();
			
			//CEepromLoadAdcDataDefault();
			
			CEepromLoadYPbPrDataDefault();
			
			//CEepromLoadBriConDataDefault();
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[4].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[4].Contrast;
			CEepromSaveBriConData();
			
			//CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			
			//CEepromLoadTvDataDefault();
			
			CEepromLoadAudioDataDefault();
			#if (_PICT_EFFECT_SUPPORT)
	               CEepromLoadPictModeDataDefault();
                     #endif
			#if (_CT_INDEPENDENT_SUPPORT)
	              CEepromLoadColorTempModeDataDefault();
                     #endif

			CEepromLoadHueSatDataDefault();

		break;


		case _VIDEO_TV_PORT:

			
			//CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=stSystemData.MonitorFlag&0xe0;//xyw
			stSystemData.ColorTemp = stSystemData.ColorTemp;
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.ucColorSetting = tEEPROM_SYSTEM_DATA.ucColorSetting;


			stSystemData.Mode = tEEPROM_SYSTEM_DATA.Mode;
			CEepromSaveSystemData();
			
			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			//stOsdUserData.Volumn = tEEPROM_OSDUSER_DATA.Volumn;
			CEepromSaveOsdUserData();
			
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[5].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[5].Contrast;
			CEepromSaveBriConData();
			
			CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			
			CEepromLoadAudioDataDefault();
			#if (_PICT_EFFECT_SUPPORT)
	               CEepromLoadPictModeDataDefault();
                     #endif
			#if (_CT_INDEPENDENT_SUPPORT)
	              CEepromLoadColorTempModeDataDefault();
                     #endif

			CEepromLoadHueSatDataDefault();
			

		   break;

		default :
		      break;
			

	}



/*
	CEepromInitialModeData();
	CEepromInitialUserFIFOModeData();
	CEepromInitialCenterModeData();
	CEepromLoadSystemDataDefault();
	CEepromLoadOsdUserDataDefault();
	CEepromLoadAdcDataDefault();
	CEepromLoadYPbPrDataDefault();
	CEepromLoadBriConDataDefault();
	CEepromLoadColorTempDataDefault();
	CEepromLoadCustomerDefaultData();
	CEepromLoadTvDataDefault();
	CEepromLoadHueSatDataDefault();
	CEepromLoadAudioDataDefault();

#if (_PICT_EFFECT_SUPPORT)
	CEepromLoadPictModeDataDefault();
#endif
#if (_CT_INDEPENDENT_SUPPORT)
	CEepromLoadColorTempModeDataDefault();
#endif
#if(_SCAN_TYPE==_TABLE_WEIGHT_SCAN) //fjyang	
	CEepromInitTvOffsetData();
#endif

#if(_MCU_TYPE == _MYSON_MTV512)
	CEepromLoadEDIDDataDefault();
#endif  // End of #if(_MCU_TYPE == _MYSON_MTV512)

    if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
    {
      	if(stSystemData.UserFIFOMode >= 15)
           	stSystemData.UserFIFOMode = 0;
        else
           	stSystemData.UserFIFOMode++;

        stFIFOModeTemp.IHFreq  = stModeInfo.IHFreq;
        stFIFOModeTemp.IVFreq  = stModeInfo.IVFreq;
        CEepromSaveUserFIFOModeData(stFIFOModeTemp);

        stModeUserData.FirstAuto    = 0;
        stModeUserData.HPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHStartPos;
        stModeUserData.VPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IVStartPos;
        stModeUserData.Clock        = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHTotal;
        stModeUserData.Phase        = 0;
        CEepromSaveModeData(stSystemData.UserFIFOMode);
        stModeInfo.ModeCurr = stSystemData.UserFIFOMode;
    }
    else if((GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE) && (stModeInfo.ModeCurr < _MAX_PRESET_MODE))
    {
        CEepromLoadModeData(stModeInfo.ModeCurr);
    }
*/
#else
	StructModeUserFIFODataType stFIFOModeTemp;
	UINT8 xdata DOSmode=stSystemData.Gamma&_BIT7;

	UINT8 language;
	//UINT8 temp;

	if (!GET_FACTORYSTATUS())
	{
		language = GET_LANGUAGE();
	}


// step 1:  pre-doing
	SET_MUTE_PROCESS(_ENABLE);

	/////////////////////////////////////////////
	/* close osd*/
	CTimerWaitForEvent(_EVENT_DEN_STOP);
	//CScalerSetBit(_OVERLAY_CTRL_6C, ~_BIT0, 0x00);
	/////////////////////////////////////////////
	/*RESET WAKE UP TIMIER AND SLEEP TIMER */
	COsdStopUserTimer();
	////////////////////////////////////////////////

// step 2:  reset-doing
	switch (GET_INPUTPORT_TYPE(stSystemData.InputSource))
	{
		case _DSUB_A0_PORT:
#if (_HDMI_SUPPORT)
		case _HDMI_PORT:
		case _HDMI_PORT2:
#endif
		case _DVI_PORT:
		case _DVI_I_A0_PORT:
			if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
			{
				CEepromLoadUserFIFOModeData((stModeInfo.ModeCurr / 4), pData);
				stFIFOModeTemp.ModeNum = pData[(stModeInfo.ModeCurr % 4) * 4];
			}

			CEepromInitialModeData();
			CEepromInitialUserFIFOModeData();
	//20081027 ccy cancel init centermodedata
	#if _CUSTOMER_TOLIP
	#else
	CEepromInitialCenterModeData();
	#endif			//reset color temp of user
			SET_COLOR_TEMP_TYPE(*(&tEEPROM_COLORTEMP_MODE_DATA.ucColorTempModeVga+GET_INPUTSOURCE_TYPE()));
			CEepromSaveColorTempModeData();
			
			stColorTempData.ColorTemp[_RED]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			stColorTempData.ColorTemp[_GREEN]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserGreen;
			stColorTempData.ColorTemp[_BLUE]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserBlue;
			CEepromSaveColorTempData();
			
			//CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xf8) |(tEEPROM_SYSTEM_DATA.MonitorFlag&0x07);
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.UserFIFOMode = tEEPROM_SYSTEM_DATA.UserFIFOMode;
			stSystemData.Gamma = (stSystemData.Gamma&(~(_BIT4|_BIT5|_BIT6))) |(tEEPROM_SYSTEM_DATA.Gamma&(_BIT4|_BIT5|_BIT6)) | DOSmode;		
			CEepromSaveSystemData();

			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			CEepromSaveOsdUserData();
			CScalerSetBit(_OVERLAY_CTRL_6C, 0x23, (GET_OSDBLENDING()<< 2));

			//CEepromLoadAdcDataDefault();
			
			//CEepromLoadYPbPrDataDefault();
			
			//CEepromLoadBriConDataDefault();
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Contrast;
			CEepromSaveBriConData();
			
			//CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			
			//CEepromLoadTvDataDefault();
			
			CEepromLoadAudioDataDefault();
			
			if((GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE) && (stModeInfo.ModeCurr < 16))
			{
				if(stSystemData.UserFIFOMode >= 15)
					stSystemData.UserFIFOMode = 0;
				else
					stSystemData.UserFIFOMode++;
				stFIFOModeTemp.IHFreq  = stModeInfo.IHFreq;
				stFIFOModeTemp.IVFreq  = stModeInfo.IVFreq;
				CEepromSaveUserFIFOModeData(stFIFOModeTemp);
				stModeUserData.FirstAuto    = 0;
				//stModeUserData.HPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHStartPos;
				//stModeUserData.VPosition    = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IVStartPos;
				//stModeUserData.Clock        = tINPUTMODE_PRESET_TABLE[stFIFOModeTemp.ModeNum].IHTotal;
				stModeUserData.HPosition    =CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IHStartPos);
				stModeUserData.VPosition    =CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IVStartPos);
				stModeUserData.Clock    =CPcGetTableData(stFIFOModeTemp.ModeNum, sPC_IHTotal);
				stModeUserData.Phase        = 0;
				CEepromSaveModeData(stSystemData.UserFIFOMode);
				stModeInfo.ModeCurr = stSystemData.UserFIFOMode;
			}
			else if((GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE) && (stModeInfo.ModeCurr < _MAX_PRESET_MODE))
			{
				CEepromLoadModeData(stModeInfo.ModeCurr);
			}
			break;
		case _VIDEO_AV_PORT:
		case _VIDEO_SV_PORT:
		case _VIDEO_TV_PORT:
			SET_COLOR_TEMP_TYPE(*(&tEEPROM_COLORTEMP_MODE_DATA.ucColorTempModeVga+GET_INPUTSOURCE_TYPE()));
			CEepromSaveColorTempModeData();
			
			stColorTempData.ColorTemp[_RED]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			stColorTempData.ColorTemp[_GREEN]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			stColorTempData.ColorTemp[_BLUE]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			CEepromSaveColorTempData();
			
			//CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xf8) |(tEEPROM_SYSTEM_DATA.MonitorFlag&0x07);
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.UserFIFOMode = tEEPROM_SYSTEM_DATA.UserFIFOMode;
			stSystemData.Gamma = (stSystemData.Gamma&(~(_BIT4|_BIT5|_BIT6))) |(tEEPROM_SYSTEM_DATA.Gamma&(_BIT4|_BIT5|_BIT6)) | DOSmode;		
			CEepromSaveSystemData();

			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			CEepromSaveOsdUserData();
			CScalerSetBit(_OVERLAY_CTRL_6C, 0x23, (GET_OSDBLENDING()<< 2));

			//CEepromLoadAdcDataDefault();
			
			//CEepromLoadYPbPrDataDefault();
			
			//CEepromLoadBriConDataDefault();
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Contrast;
			CEepromSaveBriConData();
			
			//CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			//czl 071018

			CEepromLoadHueSatDataDefault();

			//CEepromLoadTvDataDefault();
#if _CUSTOMER_CGT
			//20080130, CGT requires: reset to load default channel skip status
			if (GET_INPUTPORT_TYPE(stSystemData.InputSource)==_VIDEO_TV_PORT)
				CEepromLoadTvChStatusDefault();
#endif	//#if _CUSTOMER_CGT
			
			CEepromLoadAudioDataDefault();
			break;
		case _YPBPR_A0_PORT:
			SET_COLOR_TEMP_TYPE(*(&tEEPROM_COLORTEMP_MODE_DATA.ucColorTempModeVga+GET_INPUTSOURCE_TYPE()));
			CEepromSaveColorTempModeData();
			
			stColorTempData.ColorTemp[_RED]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			stColorTempData.ColorTemp[_GREEN]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			stColorTempData.ColorTemp[_BLUE]=tEEPROM_COLORTEMP_DATA[GET_INPUTSOURCE_TYPE()].ColorTempUserRed;
			CEepromSaveColorTempData();
			
			//CEepromLoadSystemDataDefault();
			stSystemData.MonitorFlag=(stSystemData.MonitorFlag&0xf8) |(tEEPROM_SYSTEM_DATA.MonitorFlag&0x07);
			stSystemData.Sharpness = tEEPROM_SYSTEM_DATA.Sharpness;
			stSystemData.UserFIFOMode = tEEPROM_SYSTEM_DATA.UserFIFOMode;
			stSystemData.Gamma = (stSystemData.Gamma&(~(_BIT4|_BIT5|_BIT6))) |(tEEPROM_SYSTEM_DATA.Gamma&(_BIT4|_BIT5|_BIT6)) | DOSmode;		
			CEepromSaveSystemData();

			//CEepromLoadOsdUserDataDefault();
			stOsdUserData.OsdHPos = tEEPROM_OSDUSER_DATA.OsdHPos;
			stOsdUserData.OsdVPos = tEEPROM_OSDUSER_DATA.OsdVPos;
			stOsdUserData.OsdTimeout = tEEPROM_OSDUSER_DATA.OsdTimeout;
			stOsdUserData.OsdBlending = tEEPROM_OSDUSER_DATA.OsdBlending;
			stOsdUserData.Language = tEEPROM_OSDUSER_DATA.Language;
			CEepromSaveOsdUserData();
			CScalerSetBit(_OVERLAY_CTRL_6C, 0x23, (GET_OSDBLENDING()<< 2));

			//CEepromLoadAdcDataDefault();
			
			//CEepromLoadYPbPrDataDefault();
			
			//CEepromLoadBriConDataDefault();
			stConBriData.Brightness = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Brightness;
			stConBriData.Contrast = tEEPROM_COLOR_PROC0_DATA[GET_INPUTSOURCE_TYPE()].Contrast;
			CEepromSaveBriConData();
			
			//CEepromLoadColorTempDataDefault();
			
			//Load customer default extra data
			CEepromLoadCustomerDefaultData();
			
			//CEepromLoadTvDataDefault();
			
			CEepromLoadAudioDataDefault();
			
			//CEepromLoadAdcDataDefault();
			
			CEepromLoadYPbPrDataDefault();

			CEepromInitialModeDataYPbPr();

			break;
			
		default:
			break;
	}


// step 3:  end-doing
	CEepromLoadICMColorDataDefault();

	stHueSatData = tEEPROM_HUE_SAT_DATA[GET_INPUTSOURCE_TYPE()];
	CEepromSaveHueSatData();

	//20070324, backlight
	stBacklightData.backlight[0] = tEEPROM_BACKLIGHT_DATA.backlight[0];
	CEepromSaveBacklightData();

#if _VOLUME_PT2314_SUPPORT
	CPt2314WrBalance();
	CPt2314WrTreble();
	CPt2314WrBass();
#endif

#if (_PICT_EFFECT_SUPPORT)
	SET_PICT_EFFECT(_PICT_EFFECT_USER);
	CEepromSavePictModeData();
#endif

	//20070331, user reset, call default active type only
	//stTimeData.ucTimeActiveType = tEEPROM_TIME_DATA.ucTimeActiveType;
	//CEepromSaveTimeData();

//20080213
	SET_PEAKING_CORING(*(&tEEPROM_PEAKING_DATA.PeakingCoringVGA+GET_INPUTSOURCE_TYPE()));
#if _SHARPNESS_REWRITE
	CEepromSavePeakingCoringData();
#endif	//#if _SHARPNESS_REWRITE



#endif
#if(_PCB_TYPE==_PCB_PT2662A)// add by xyw 071029
      //modified by xyw 071113
	//for(temp=0;temp<GET_TV_MAX_CH();temp++)
	//{
	//  SET_CURR_AUDIO_SYS(_TV_AUDIO_SYS_AUTO);
	  //CEepromSaveTvPdbData(temp, &stTvPdb.chinfo);
	  //CEepromSaveTvAUDIO_SYSData(temp, &stTvPdb.chinfo);
	//}



    //if(GET_INPUTPORT_TYPE(stSystemData.InputSource) == _VIDEO_TV_PORT)
    	//{

	//SET_CURR_AUDIO_SYS(_TV_AUDIO_SYS_AUTO);
	//CEepromSaveTvPdbData(stTvInfo.CurChn, &stTvPdb.chinfo);
    	//}
#endif

	if (!GET_FACTORYSTATUS())
	{
		SET_LANGUAGE(language);
		CEepromSaveOsdUserData();
	}

}

BYTE CEepromFlasReadOneByte(UINT32 ucFlashAddr)
{
	MCU_COMMON_INST_EN_FF60 = 0x5A;	//Common instruction, Read Num = 1
	MCU_COMMON_OP_CODE_FF61 = 0x03;	//Read 
	MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((ucFlashAddr & 0xff0000) >>16);//High byte addr
	MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((ucFlashAddr & 0x00ff00) >>8);//Middle byte addr
	MCU_FLASH_PROG_ISP2_FF66 = (BYTE)(ucFlashAddr & 0x0000ff);//Low byte addr
	MCU_COMMON_INST_EN_FF60 |= 0x01;	//Common instruction enable
	
	while ((MCU_COMMON_INST_EN_FF60 & 0x01) == 0x01) 
	{ ; }

	return MCU_COMMON_INST_RD_PT0_FF67;
}

void CEepromFlashLoadData(UINT32 ucFlashAddr, BYTE ucStartIndex, BYTE usEndIndex, BYTE *pReadArray)
{
	BYTE m;
	BYTE AddrBuf, ValBuf;

	//read index of sector
	for(m=0; m<32; m++)
	{
		AddrBuf = CEepromFlasReadOneByte(ucFlashAddr + 0xF80 + m);
		ValBuf = (BYTE)((ucFlashAddr + 0xF80 + m) & 0x00001f);

		if(AddrBuf!=ValBuf)
		{
			if(m!=0)
				ucFlashAddr += ((m-1)*128);
			
			break;
		}
	}	

	for (m=ucStartIndex; m<usEndIndex; m++)
	{
		MCU_COMMON_INST_EN_FF60 = 0x5A;	//Common instruction, Read Num = 1
		MCU_COMMON_OP_CODE_FF61 = 0x03;	//Read 
		MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((ucFlashAddr & 0xff0000) >>16);//High byte addr
		MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((ucFlashAddr & 0x00ff00) >>8);//Middle byte addr
		MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((ucFlashAddr & 0x0000ff) + m);//Low byte addr
		MCU_COMMON_INST_EN_FF60 |= 0x01;	//Common instruction enable
	
		while ((MCU_COMMON_INST_EN_FF60 & 0x01) == 0x01) 
		{ ; }

		*pReadArray++ = MCU_COMMON_INST_RD_PT0_FF67;
	}
}

void CEepromFlashEraseSector(UINT32 ucFlashAddr)
{
	//Enable WEL(Write Enable Latch)
	MCU_COMMON_INST_EN_FF60 = 0x60;
	MCU_COMMON_OP_CODE_FF61 = 0x06;
	MCU_COMMON_INST_EN_FF60 |= 0x01;

	MCU_COMMON_INST_EN_FF60 = 0xB8;
#if _SPI_FLASH_EN25F40
	//20090415, update for EON ENF04, 4Mbit, sector erase command
	MCU_COMMON_OP_CODE_FF61 = 0x20;//0xD7;
#else
	MCU_COMMON_OP_CODE_FF61 = 0xD7;
#endif
	MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((ucFlashAddr & 0xff0000) >>16);//High byte addr
	MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((ucFlashAddr & 0x00ff00) >>8);//Middle byte addr
	MCU_FLASH_PROG_ISP2_FF66 = (BYTE)(ucFlashAddr & 0x0000ff);//Low byte addr
	MCU_COMMON_INST_EN_FF60 |= 0x01;
}

BYTE xdata EraseCount = 0;
UINT32 xdata FlashBufAddr = 0x3C000;
void CEepromFlashSaveData(UINT32 ucFlashAddr, BYTE ucStartIndex, BYTE usEndIndex, BYTE *pWriteArray)
{
	BYTE m,n;
	BYTE AddrBuf, ValBuf;

#if _FLASH_PROTECT_SUPPORT  //090427
	CFlashWriteStatusByte(0x80|(0<<2));
#endif

	if(EraseCount == 0)
		CEepromFlashEraseSector(FlashBufAddr);

	//read and record index of sector
	for(m=0; m<32; m++)
	{
		AddrBuf = CEepromFlasReadOneByte(ucFlashAddr + 0xF80 + m);
		ValBuf = (BYTE)((ucFlashAddr + 0xF80 + m) & 0x00001f);

		if(AddrBuf!=ValBuf)
		{
			if(m!=0)
			{
				MCU_FLASH_PROG_ISP0_FF64 = (BYTE)(((ucFlashAddr + 0xF80) & 0xff0000) >>16);
				MCU_FLASH_PROG_ISP1_FF65 = (BYTE)(((ucFlashAddr + 0xF80) & 0x00ff00) >>8);
				MCU_FLASH_PROG_ISP2_FF66 = (BYTE)(((ucFlashAddr + 0xF80) & 0x0000ff) + m);

				ucFlashAddr += ((m-1)*128);
			}
			else
			{
				CEepromFlashEraseSector(ucFlashAddr);
					
				MCU_FLASH_PROG_ISP0_FF64 = (BYTE)(((ucFlashAddr + 0xF80) & 0xff0000) >>16);
				MCU_FLASH_PROG_ISP1_FF65 = (BYTE)(((ucFlashAddr + 0xF80) & 0x00ff00) >>8);
				MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((ucFlashAddr + 0xF80) & 0x0000ff);
			}

			FLASH_DATA_BUF[0] =  ValBuf;
			MCU_PROG_LEN_FF71 = 0x00; //write one byte record index
			MCU_PROG_INST_FF6F |= 0x20; //enable program
			while ((MCU_PROG_INST_FF6F & 0x20) == 0x20)
			{ ; }
			
			break;
		}
	}	

	//save data to assign sector buffer
	if(ValBuf!=0)
	{
		for (m=0; m<8; m++)
		{
			for(n=0; n<16; n++)
			{
				MCU_COMMON_INST_EN_FF60 = 0x5A;	//Common instruction, Read Num = 1
				MCU_COMMON_OP_CODE_FF61 = 0x03;	//Read 
				MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((ucFlashAddr & 0xff0000) >>16);
				MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((ucFlashAddr & 0x00ff00) >>8);
				MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((ucFlashAddr & 0x0000ff) + m*16 + n);
				MCU_COMMON_INST_EN_FF60 |= 0x01;	//Common instruction enable
				
				while ((MCU_COMMON_INST_EN_FF60 & 0x01) == 0x01) 
				{ ; }

				FLASH_DATA_BUF[n] = MCU_COMMON_INST_RD_PT0_FF67;
			}

			MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((FlashBufAddr & 0xff0000) >>16);
			MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((FlashBufAddr & 0x00ff00) >>8);
			MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((FlashBufAddr & 0x0000ff) + m*16);
			MCU_PROG_LEN_FF71 = 0x0F; //write 16 bytes
			MCU_PROG_INST_FF6F |= 0x20; //enable program

			while ((MCU_PROG_INST_FF6F & 0x20) == 0x20)
			{ ; }
		}
	}

	if(ValBuf!=0)
	{
		ucFlashAddr += 128;
	}

	if(ValBuf==31)
	{
		ucFlashAddr -= (31*128);
		CEepromFlashEraseSector(ucFlashAddr);

		MCU_FLASH_PROG_ISP0_FF64 = (BYTE)(((ucFlashAddr + 0xF80) & 0xff0000) >>16);
		MCU_FLASH_PROG_ISP1_FF65 = (BYTE)(((ucFlashAddr + 0xF80) & 0x00ff00) >>8);
		MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((ucFlashAddr + 0xF80) & 0x0000ff);

		FLASH_DATA_BUF[0] =  0x00;
		MCU_PROG_LEN_FF71 = 0x00; //write one byte record index
		MCU_PROG_INST_FF6F |= 0x20; //enable program
		while ((MCU_PROG_INST_FF6F & 0x20) == 0x20)
		{ ; }
	}

	//read assign sector buffer, modify and write to assign sector.
	for (m=0; m<8; m++)
	{
		for(n=0; n<16; n++)
		{
			MCU_COMMON_INST_EN_FF60 = 0x5A;	//Common instruction, Read Num = 1
			MCU_COMMON_OP_CODE_FF61 = 0x03;	//Read 
			MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((FlashBufAddr & 0xff0000) >>16);
			MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((FlashBufAddr & 0x00ff00) >>8);
			MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((FlashBufAddr & 0x0000ff) + m*16 + n);
			MCU_COMMON_INST_EN_FF60 |= 0x01;	//Common instruction enable
		
			while ((MCU_COMMON_INST_EN_FF60 & 0x01) == 0x01) 
			{ ; }

			if((m*16+n) == ucStartIndex)
			{
				FLASH_DATA_BUF[n] = *pWriteArray++;
				if(ucStartIndex != (usEndIndex-1))
					ucStartIndex++;
			}
			else
				FLASH_DATA_BUF[n] = MCU_COMMON_INST_RD_PT0_FF67;

		}

		MCU_FLASH_PROG_ISP0_FF64 = (BYTE)((ucFlashAddr & 0xff0000) >>16);
		MCU_FLASH_PROG_ISP1_FF65 = (BYTE)((ucFlashAddr & 0x00ff00) >>8);
		MCU_FLASH_PROG_ISP2_FF66 = (BYTE)((ucFlashAddr & 0x0000ff) + m*16);
		MCU_PROG_LEN_FF71 = 0x0F; //write 16 bytes
		MCU_PROG_INST_FF6F |= 0x20; //enable program

		while ((MCU_PROG_INST_FF6F & 0x20) == 0x20)
		{ ; }
	}

	EraseCount++;
	FlashBufAddr += 128;
	if(EraseCount == 32)
		EraseCount = 0;
	if(FlashBufAddr == 0x40000)
		FlashBufAddr = 0x3C000;

#if _FLASH_PROTECT_SUPPORT   //090427
	CFlashWriteStatusByte(0x80|(7<<2));
#endif

}

#if _HDCP_WR_BY_RS232
#if !_SPI_FLASH_EN25F40
//--------------------------------------------------
// Description  : Write data to the external flash
// Input Value  : ucDeviceAddr  --> Flash Sector
//                ucStartAddr   --> Start address of selected flash sector
//                usLength      --> Numbers of data we want to write
//                pWriteArray   --> Writing data array
// Output Value : Write result (Fail/Success)
//--------------------------------------------------
bit CEepromFlashWrite(BYTE ucFlashSector, BYTE ucStartAddr, BYTE usLength, BYTE *pWriteArray)
{
	UINT32	FlashAddr;

	if(usLength == 0)
		return _FAIL;

	if(((ucStartAddr+usLength)>128) && (ucStartAddr <= 128))
	{
		// one sector
		#if _HDCP_WR_BY_RS232
			FlashAddr = (UINT32)(_EEPROM_FLASH_ADDRESS+(UINT32)(ucFlashSector*4096));
		#else
			FlashAddr = (UINT32)(_EEPROM_ADDRESS+(UINT32)(ucFlashSector*4096));
		#endif
		CEepromFlashSaveData(FlashAddr, ucStartAddr, 128, pWriteArray);

		// two sector
		FlashAddr += 4096;
		CEepromFlashSaveData(FlashAddr, 0, (ucStartAddr+usLength-128), pWriteArray);

	}	
	else
	{
	#if _HDCP_WR_BY_RS232
		FlashAddr = (UINT32)(_EEPROM_FLASH_ADDRESS+(UINT32)(ucFlashSector*4096));
	#else
		FlashAddr = (UINT32)(_EEPROM_ADDRESS+(UINT32)(ucFlashSector*4096));
	#endif
		if(ucStartAddr >= 128)
		{
				FlashAddr += 4096;
				ucStartAddr -= 128;
		}

		CEepromFlashSaveData(FlashAddr, ucStartAddr, (ucStartAddr+usLength), pWriteArray);
	}
	return _SUCCESS;

}

//--------------------------------------------------
// Description  : Read data from the external flash
// Input Value  : ucFlashSector  --> Flash Sector
//                ucStartAddr   --> Start address of selected flash sector
//                usLength      --> Numbers of data we want to read
//                pReadArray    --> Result array
// Output Value : Reading result (Fail/Success)
//--------------------------------------------------
bit CEepromFlashRead(BYTE ucFlashSector, BYTE ucStartAddr, BYTE usLength, BYTE *pReadArray)
{
	UINT32	FlashAddr;

	if(usLength == 0)
		return _FAIL;

	if(((ucStartAddr+usLength)>128) && (ucStartAddr <= 128))
	{
		// one sector
		#if _HDCP_WR_BY_RS232
		FlashAddr = (UINT32)(_EEPROM_FLASH_ADDRESS+(UINT32)(ucFlashSector*4096));
		#else
		FlashAddr = (UINT32)(_EEPROM_ADDRESS+(UINT32)(ucFlashSector*4096));
		#endif
		CEepromFlashLoadData(FlashAddr, ucStartAddr, 128, pReadArray);
		
		// two sector
		FlashAddr += 4096;
		CEepromFlashLoadData(FlashAddr, 0, (ucStartAddr+usLength-128), pReadArray);
	}
	else
	{
	#if _HDCP_WR_BY_RS232
		FlashAddr = (UINT32)(_EEPROM_FLASH_ADDRESS+(UINT32)(ucFlashSector*4096));
	#else
		FlashAddr = (UINT32)(_EEPROM_ADDRESS+(UINT32)(ucFlashSector*4096));
	#endif

		if(ucStartAddr >= 128)
		{
				FlashAddr += 4096;
				ucStartAddr -= 128;
		}
		CEepromFlashLoadData(FlashAddr, ucStartAddr, (ucStartAddr+usLength), pReadArray);		
	}
	return _SUCCESS;

}
#endif	//#if _HDCP_WR_BY_RS232


#if _HDCP_WR_BY_RS232
bit CEepromWriteFlash(WORD usAddr, WORD usLength, BYTE *pWriteArray)
{
     bit done;
    // BYTE addrH,addrL;
    // addrH=(BYTE)((usAddr & 0xff00) >> 7);
    // addrL=(BYTE)(usAddr & 0x00ff);
     //addrH=+1;
	 done=CEepromFlashWrite((BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pWriteArray);
	 CTimerDelayXms(10);
	return done;
}

bit CEepromReadFlash(WORD usAddr, WORD usLength, BYTE *pReadArray)
{
    	// BYTE addrH,addrL;
     	//addrH=(BYTE)((usAddr & 0xff00) >> 7);
    	// addrL=(BYTE)(usAddr & 0x00ff);
   	// addrH=+1;
	return CEepromFlashRead((BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pReadArray);
}
#endif	//#if _HDCP_WR_BY_RS232

#if 0//_HDCP_WR_BY_RS232
void CEepromLoadHdcpKeyDefualtData(void)
{
	BYTE i,j;
	for(j=0;j<20;j++)
	{
		for(i=0;i<16;i++)
		{
			pData[i]=tHDCP_KEY_TABLE_0[i+16*j];
		}
		CEepromWriteFlash(_EEPROM_FLASH_ADDRESS+16*j, 16, pData);
		CTimerDelayXms(10);
	}
}
#endif	//#if _HDCP_WR_BY_RS232
#endif	//#if _HDCP_WR_BY_RS232


//20080421, DDC support for VGA. start...
void CEepromLoadFlashEdidData(void)
{
	//CEepromFlashRead(0x00, 0x00, 128, MCU_DDCRAM_VGA);
	CEepromFlashLoadData(_EEPROM_FLASH_EDID_ADDRESS, 0x00, 128, MCU_DDCRAM_VGA);
}

void CEepromSaveFlashEdidData(void)
{
	//CEepromFlashWrite(0x00, 0x00, 128, MCU_DDCRAM_VGA);
	CEepromFlashSaveData(_EEPROM_FLASH_EDID_ADDRESS, 0x00, 128, MCU_DDCRAM_VGA);

}
void CEepromLoadFlashEdidDataDefault(void)
{
//20080421, DDC support for digital port 0. start...
	WORD cnt;

	CEepromFlashSaveData(_EEPROM_FLASH_EDID_ADDRESS, 0x00, 128, tVGA_EDID_DATA);
	
	for(cnt=0;cnt<128;cnt++) 
	{
		MCU_DDCRAM_VGA[cnt]=	 tVGA_EDID_DATA[cnt];
	}

	
#if _HDMI_EDID_RW
	CEepromFlashSaveData(_EEPROM_FLASH_EDID_HDMI0_ADDRESS, 0x00, 128, &tHDMI_EDID_DATA[0]);
	CEepromFlashSaveData(_EEPROM_FLASH_EDID_HDMI1_ADDRESS, 0x00, 128, &tHDMI_EDID_DATA[128]);
	for(cnt=0;cnt<256;cnt++) 
	{
		MCU_DDCRAM_HDMI[cnt]=	 tHDMI_EDID_DATA[cnt];
	}
#endif  // #if _HDMI_EDID_RW
//20080421, DDC support for digital port 0. end...

}
//20080421, DDC support for VGA. end...



//20080421, DDC support for digital port 0. start...
#if _HDMI_EDID_RW
void CEepromLoadFlashEdidHdmiData(void)
{
	CEepromFlashLoadData(_EEPROM_FLASH_EDID_HDMI0_ADDRESS, 0x00, 128, &MCU_DDCRAM_HDMI[0]);
	CEepromFlashLoadData(_EEPROM_FLASH_EDID_HDMI1_ADDRESS, 0x00, 128, &MCU_DDCRAM_HDMI[128]);
}
void CEepromSaveFlashEdidHdmiData(void)
{
	CEepromFlashSaveData(_EEPROM_FLASH_EDID_HDMI0_ADDRESS, 0x00, 128, &MCU_DDCRAM_HDMI[0]);
	CEepromFlashSaveData(_EEPROM_FLASH_EDID_HDMI1_ADDRESS, 0x00, 128, &MCU_DDCRAM_HDMI[128]);
}
#endif  // #if _HDMI_EDID_RW
//20080421, DDC support for digital port 0. end...

//--------------------------------------------------
// Description  : Eeprom write function
// Input Value  : usAddr        --> absolute address
//                usLength      --> Numbers of data we want to write
//                pWriteArray   --> Writing data array
// Output Value : Return _SUCCESS if succeed
//--------------------------------------------------
bit CEepromWrite(WORD usAddr, WORD usLength, BYTE *pWriteArray)
{
#if(_MEMORY_LOCATION == _FLASH)
	return CEepromFlashWrite((BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pWriteArray);
#else
	return CI2cWrite(_EEPROM_ADDRESS + (BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pWriteArray);
#endif
}

/**
* CEepromRead
* Read some byte from Eeprom
* @param <usAddr> {The address in Eeprom}
* @param <usLength> {The number of byte to read}
* @param <pReadArray> {The array to store data}
* @return {Return _SUCCESS if succeed}
*
*/
bit CEepromRead(WORD usAddr, WORD usLength, BYTE *pReadArray)
{
#if(_MEMORY_LOCATION == _FLASH)
	return CEepromFlashRead((BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pReadArray);
#else
	return CI2cRead(_EEPROM_ADDRESS + (BYTE)((usAddr & 0xff00) >> 7), (BYTE)(usAddr & 0x00ff), usLength, pReadArray);
#endif
}
//--------------------------------------------------
// Description  : Save mode setting data, such as FirstAuto,
//                HPosition, VPosition, Clock and Phase.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveModeData(BYTE ucMode)
{
    if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    {
        CEepromWrite(_MODE_DATA_0_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto);
    }
    else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)
    {
        CEepromWrite(_USER_FIFO_MODE_DATA_1_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto);
    }
}

//--------------------------------------------------
// Description  : Load mode setting data, such as FirstAuto,
//                HPosition, VPosition, Clock and Phase.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadModeData(BYTE ucMode)
{
    if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    {
        if(CEepromRead(_MODE_DATA_0_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto) == _FAIL)
        {
            stModeUserData.FirstAuto    = 0;
            stModeUserData.HPosition    = stModeInfo.IHStartPos;
            stModeUserData.VPosition    = stModeInfo.IVStartPos;
            stModeUserData.Clock        = stModeInfo.IHTotal;
            stModeUserData.Phase        = 0;
        }
    }
    else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)
    {
        if(CEepromRead(_USER_FIFO_MODE_DATA_1_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto) == _FAIL)
        {
            stModeUserData.FirstAuto    = 0;
            stModeUserData.HPosition    = stModeInfo.IHStartPos;
            stModeUserData.VPosition    = stModeInfo.IVStartPos;
            stModeUserData.Clock        = stModeInfo.IHTotal;
            stModeUserData.Phase        = 0;
        }
    }
}

//--------------------------------------------------
// Description  : Initial mode setting data with defaults
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromInitialModeData(void)
{
    BYTE modecnt, modetype;

    modetype = GET_MODE_SEARCH_TYPE();
    SET_MODE_SEARCH_TYPE(_PRESET_MODE_TYPE);

    for(modecnt=0;modecnt<_MAX_PRESET_MODE;modecnt++)
    {
        stModeUserData.FirstAuto    = 0;
        //stModeUserData.HPosition    = tINPUTMODE_PRESET_TABLE[modecnt].IHStartPos;
        //stModeUserData.VPosition    = tINPUTMODE_PRESET_TABLE[modecnt].IVStartPos;
        //stModeUserData.Clock        = tINPUTMODE_PRESET_TABLE[modecnt].IHTotal;
	 stModeUserData.HPosition    = CPcGetTableData(modecnt, sPC_IHStartPos);
        stModeUserData.VPosition    = CPcGetTableData(modecnt, sPC_IVStartPos);
        stModeUserData.Clock        = CPcGetTableData(modecnt, sPC_IHTotal);
        stModeUserData.Phase        = 0;

        CEepromSaveModeData(modecnt);
    }

    for(modecnt=0;modecnt<8;modecnt++)
    {
        CEepromWrite(_USER_FIFO_MODE_DATA_1_ADDRESS + (modecnt * 16), 16, tEEPROM_USER_FIFO_MODE_DEFAULT);
    }

    SET_MODE_SEARCH_TYPE(modetype);
}

//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  : Save user FIFO mode data, such as ModeNum,
//                IHFreq, IVFreq.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveUserFIFOModeData(StructModeUserFIFODataType stUserFIFOMode)
{
    stUserFIFOMode.IHFreq = ((stUserFIFOMode.IVFreq & 0x0f00) << 4) | (stUserFIFOMode.IHFreq & 0x0fff);
    stUserFIFOMode.IVFreq = ((stUserFIFOMode.IVFreq & 0x00ff) << 8);
    CEepromWrite(_USER_FIFO_MODE_DATA_0_ADDRESS + (stSystemData.UserFIFOMode * 4), 4, &stUserFIFOMode.ModeNum);
}

//--------------------------------------------------
// Description  : Load 4 sets of user FIFO mode data.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadUserFIFOModeData(BYTE ucNum, BYTE *pArray)
{
    CEepromRead(_USER_FIFO_MODE_DATA_0_ADDRESS + (ucNum * 16), 16, pArray);
}

//--------------------------------------------------
// Description  : Initial user FIFO mode data with defaults
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromInitialUserFIFOModeData(void)
{
    BYTE modecnt;

    for(modecnt=0;modecnt<4;modecnt++)
    {
        CEepromWrite(_USER_FIFO_MODE_DATA_0_ADDRESS + (modecnt * 16), 16, tEEPROM_USER_FIFO_MODE_DEFAULT);
    }
}

//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  :
// Input Value  :
// Output Value : None
//--------------------------------------------------
void CEepromSaveCenterModeData(BYTE ucMode)
{
    if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    CEepromWrite(_MODE_CENTER_DATA_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserCenterDataType), (BYTE *)&stModeUserCenterData.CenterHPos);
    else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)   
        CEepromWrite(_MODE_CENTER_DATA_ADDRESS + (WORD)_MAX_PRESET_MODE * 8 + (WORD)ucMode * 8, sizeof(StructModeUserCenterDataType), (BYTE *)&stModeUserCenterData.CenterHPos);
    }

//--------------------------------------------------
// Description  :
// Input Value  :
// Output Value : None
//--------------------------------------------------
void CEepromLoadCenterModeData(BYTE ucMode)
{
    if(GET_MODE_SEARCH_TYPE() == _PRESET_MODE_TYPE)
    {
    	if(CEepromRead(_MODE_CENTER_DATA_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserCenterDataType), (BYTE *)&stModeUserCenterData.CenterHPos) == _FAIL)
    	{
        	stModeUserCenterData.CenterHPos     = stModeInfo.IHStartPos;
        	stModeUserCenterData.CenterVPos     = stModeInfo.IVStartPos;
        	stModeUserCenterData.CenterClock    = stModeInfo.IHTotal;
    	}
 	}
   	else if(GET_MODE_SEARCH_TYPE() == _USER_MODE_TYPE)
    {
        if(CEepromRead(_MODE_CENTER_DATA_ADDRESS + (WORD)_MAX_PRESET_MODE * 8 + (WORD)ucMode * 8, sizeof(StructModeUserCenterDataType), (BYTE *)&stModeUserCenterData.CenterHPos) == _FAIL)
        {
            stModeUserCenterData.CenterHPos     = stModeInfo.IHStartPos;
            stModeUserCenterData.CenterVPos     = stModeInfo.IVStartPos;
            stModeUserCenterData.CenterClock    = stModeInfo.IHTotal;
        }
    }
}

//--------------------------------------------------
// Description  : Initial mode setting data with defaults
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromInitialCenterModeData(void)
{
    BYTE modecnt, modetype;

    modetype = GET_MODE_SEARCH_TYPE();
    SET_MODE_SEARCH_TYPE(_PRESET_MODE_TYPE);

    for(modecnt=0;modecnt<_MAX_PRESET_MODE;modecnt++)
    {
        //stModeUserCenterData.CenterHPos     = tINPUTMODE_PRESET_TABLE[modecnt].IHStartPos;
        //stModeUserCenterData.CenterVPos     = tINPUTMODE_PRESET_TABLE[modecnt].IVStartPos;
        //stModeUserCenterData.CenterClock    = tINPUTMODE_PRESET_TABLE[modecnt].IHTotal;
        stModeUserCenterData.CenterHPos     = CPcGetTableData(modecnt, sPC_IHStartPos);
        stModeUserCenterData.CenterVPos     = CPcGetTableData(modecnt, sPC_IVStartPos);
        stModeUserCenterData.CenterClock    = CPcGetTableData(modecnt, sPC_IHTotal);
        CEepromSaveCenterModeData(modecnt);
    }

    for(modecnt=0;modecnt<8;modecnt++)
    {
        CEepromWrite(_MODE_CENTER_DATA_ADDRESS + (WORD)_MAX_PRESET_MODE * 8 + ((WORD)modecnt * 16), 16, tEEPROM_USER_FIFO_MODE_DEFAULT);
    }

    SET_MODE_SEARCH_TYPE(modetype);
}

//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  : Save system data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveSystemData(void)
{
    CEepromWrite(_SYSTEM_DATA_ADDRESS, sizeof(StructSystemDataType), &stSystemData.MonitorFlag);
    CEepromWrite(_ICM_COLOR_ADDRESS, sizeof(StructICMColor), &stICMColor.ICM_COLOR[0]);
}

/**
* CEepromLoadSystemData
* Load system data
* @param <none>
* @return {none}
*
*/
void CEepromLoadSystemData(void)
{
    CEepromRead(_SYSTEM_DATA_ADDRESS, sizeof(StructSystemDataType), &stSystemData.MonitorFlag);
    CEepromRead(_ICM_COLOR_ADDRESS, sizeof(StructICMColor), &stICMColor.ICM_COLOR[0]);
}

//--------------------------------------------------
// Description  : Load default system data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadSystemDataDefault(void)
{
    stSystemData = tEEPROM_SYSTEM_DATA;
    stICMColor = tEEPROM_ICM_COLOR;
    CEepromWrite(_SYSTEM_DATA_ADDRESS, sizeof(StructSystemDataType), &tEEPROM_SYSTEM_DATA.MonitorFlag);
    CEepromWrite(_ICM_COLOR_ADDRESS, sizeof(StructICMColor), &tEEPROM_ICM_COLOR.ICM_COLOR[0]);
}

//--------------------------------------------------
// Description  : Load default icm data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadICMColorDataDefault(void)
{
    stICMColor = tEEPROM_ICM_COLOR;
    CEepromWrite(_ICM_COLOR_ADDRESS, sizeof(StructICMColor), &tEEPROM_ICM_COLOR.ICM_COLOR[0]);
}

//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  : Save OSD data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveOsdUserData(void)
{
    CEepromWrite(_OSDUSER_DATA_ADDRESS, sizeof(StructOsdUserDataType), &stOsdUserData.OsdHPos);
}

/**
* CEepromLoadOsdUserData
* Load OSD data
* @param <none>
* @return {none}
*
*/
void CEepromLoadOsdUserData(void)
{
    CEepromRead(_OSDUSER_DATA_ADDRESS, sizeof(StructOsdUserDataType), &stOsdUserData.OsdHPos);
}

//--------------------------------------------------
// Description  : Load default OSD data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadOsdUserDataDefault(void)
{
    CEepromWrite(_OSDUSER_DATA_ADDRESS, sizeof(StructOsdUserDataType), &tEEPROM_OSDUSER_DATA.OsdHPos);
    stOsdUserData = tEEPROM_OSDUSER_DATA;
}

//----------------------------------------------------------------------------------------------------

//--------------------------------------------------
// Description  : Save ADC data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveAdcData(void)
{
	if(GET_INPUTSOURCE_TYPE() == _SOURCE_VGA)
	CEepromWrite(_ADC_DATA_ADDRESS, sizeof(StructAdcDataType), &stAdcData.AdcGain[_RED]);
	else
	CEepromWrite(_YPbPr_DATA_ADDRESS, sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
}

/**
* CEepromLoadAdcData
* Load ADC data
* @param <none>
* @return {none}
*
*/
void CEepromLoadAdcData(void)
{
	CEepromRead(_ADC_DATA_ADDRESS, sizeof(StructAdcDataType), &stAdcData.AdcGain[_RED]);
	CEepromRead(_YPbPr_DATA_ADDRESS, sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
}

//--------------------------------------------------
// Description  : Load default ADC data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadAdcDataDefault(void)
{
	CEepromWrite(_ADC_DATA_ADDRESS, sizeof(StructAdcDataType), &tEEPROM_ADC_DATA.AdcGain[_RED]);
    stAdcData = tEEPROM_ADC_DATA;
}

//--------------------------------------------------
// Description  : Save Brightness/Contrast data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveBriConData(void)
{
	CEepromWrite(_COLOR_PROC0_ADDRESS + GET_INPUTSOURCE_TYPE() * sizeof(StructColorProc0DataType), sizeof(StructColorProc0DataType), &stConBriData.Brightness);
}

/**
* CEepromLoadBriConData
* Load Brightness and Contrast data
* @param <none>
* @return {none}
*
*/
void CEepromLoadBriConData(void)
{
     CEepromRead(_COLOR_PROC0_ADDRESS + GET_INPUTSOURCE_TYPE() * sizeof(StructColorProc0DataType), sizeof(StructColorProc0DataType), &stConBriData.Brightness);
}

//--------------------------------------------------
// Description  : Load default Brightness/Contrast data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadBriConDataDefault(void)
{
    CEepromWrite(_COLOR_PROC0_ADDRESS, sizeof(StructColorProc0DataType) * 4, &tEEPROM_COLOR_PROC0_DATA[0].Brightness);
    //CEepromLoadBriConData();
    stConBriData = tEEPROM_COLOR_PROC0_DATA[stSystemData.InputSource];
}
#if _BACKLIGHT_SUPPORT
//20070324, backlight
//we only support the same backlight data: backlight[0];
//if other input need different backlight value, backlight[..] can be used.
void CEepromSaveBacklightData(void)
{
    	CEepromWrite(_BACKLIGHT_DATA_ADDRESS, sizeof(stBacklightData), &stBacklightData.backlight[0]);
}

void CEepromLoadBacklightData(void)
{
    	CEepromRead(_BACKLIGHT_DATA_ADDRESS, sizeof(stBacklightData), &stBacklightData.backlight[0]);
}

void CEepromLoadBacklightDataDefault(void)
{
	CEepromWrite(_BACKLIGHT_DATA_ADDRESS, sizeof(stBacklightData), &tEEPROM_BACKLIGHT_DATA.backlight[0]);
	CEepromLoadBacklightData();
}
#endif
//----------------------------------------------------------------------------------------------------
#if (_CT_INDEPENDENT_SUPPORT)
void CEepromSaveColorTempModeData(void)
{
    CEepromWrite(_COLORTEMP_MODE_DATA_ADDRESS, sizeof(StructColorTempModeType), &stColorTempMode.ucColorTempModeVga);
}

void CEepromLoadColorTempModeData(void)
{
    CEepromRead(_COLORTEMP_MODE_DATA_ADDRESS, sizeof(StructColorTempModeType), &stColorTempMode.ucColorTempModeVga);
}

void CEepromLoadColorTempModeDataDefault(void)
{
    stColorTempMode = tEEPROM_COLORTEMP_MODE_DATA;
    CEepromWrite(_COLORTEMP_MODE_DATA_ADDRESS, sizeof(StructColorTempModeType), &tEEPROM_COLORTEMP_MODE_DATA.ucColorTempModeVga);
}
#endif
//--------------------------------------------------
// Description  : Save Color Temperature data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveColorTempData(void)
{
	CEepromWrite(_COLORTEMP_DATA_ADDRESS + _CT_GROUP_SIZE * GET_INPUTSOURCE_TYPE() + sizeof(StructColorProc1DataType) * GET_COLOR_TEMP_TYPE(), sizeof(StructColorProc1DataType), &stColorTempData.ColorTemp[_RED]);
}

/**
* CEepromLoadColorTempData
* Load Color Temperature data
* @param <none>
* @return {none}
*
*/
void CEepromLoadColorTempData(void)
{
	CEepromRead(_COLORTEMP_DATA_ADDRESS + _CT_GROUP_SIZE* GET_INPUTSOURCE_TYPE() + sizeof(StructColorProc1DataType) * GET_COLOR_TEMP_TYPE(), sizeof(StructColorProc1DataType), &stColorTempData.ColorTemp[_RED]);
}

//--------------------------------------------------
// Description  : Load default Color Temperature data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadColorTempDataDefault(void)
{
	UINT8 i;
	
	for (i=0; i<4; i++)
	{
		CEepromWrite(_COLORTEMP_DATA_ADDRESS+_CT_GROUP_SIZE * i, _CT_GROUP_SIZE, &tEEPROM_COLORTEMP_DATA[i].ColorTemp9300Red);
	}

	CEepromLoadColorTempData();
}

//--------------------------------------------------
// Description  : Save tvInfo data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadTvChStatus(void)
{
	CEepromRead(_TVCH_STATUS_ADDRESS, sizeof(StructTvChStatus), &stTvChStatus.ChStatus[0]);
}
//--------------------------------------------------
// Description  : Save tvInfo data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveTvChStatus(void)
{
	CEepromWrite(_TVCH_STATUS_ADDRESS, sizeof(StructTvChStatus), &stTvChStatus.ChStatus[0]);
}

#if 1//_CUSTOMER_CGT
void CEepromLoadTvChStatusDefault(void)
{
	UINT8 i;
	UINT8 tvStatusBytes;

	pData[0] = 0xff;	//default enable all channel
	//20071129
	//for (i=0; i<GET_TV_MAX_CH()/8; i++)
	tvStatusBytes = GET_TV_MAX_CH()/8;
	tvStatusBytes = 8 * tvStatusBytes;
	if (GET_TV_MAX_CH() > tvStatusBytes)
		tvStatusBytes = GET_TV_MAX_CH()/8 + 1;
	for (i=0; i<tvStatusBytes; i++)
	{
		//20070402
		CEepromWrite(_TVCH_STATUS_ADDRESS+i, 1, pData);
		stTvChStatus.ChStatus[i] = pData[0];
	}
}
#endif	//#if _CUSTOMER_CGT

//--------------------------------------------------
// Description  : Save tvInfo data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveTvChStatusOfChn(UINT8 chn)
{
	UINT8 position;
	//check chn range
	if(chn >= GET_TV_MAX_CH())
		return;

	position = chn/8;
	CEepromWrite(_TVCH_STATUS_ADDRESS+position, 1, &stTvChStatus.ChStatus[position]);
}

//--------------------------------------------------
// Description  : Save tvInfo data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveTvData(void)
{
	CEepromWrite(_TV_DATA_ADDRESS, sizeof(StructTvDataType), &stTvInfo.CurSigMode);
	CEepromSaveTvChStatus();
}

/**
* CEepromLoadTvData
* Load TV information data
* @param <none>
* @return {none}
*
*/
void CEepromLoadTvData(void)
{
	CEepromRead(_TV_DATA_ADDRESS, sizeof(StructTvDataType), &stTvInfo.CurSigMode);

	CEepromLoadTvChStatus();

	CEepromGetTvPdbData(stTvInfo.CurChn, &stTvPdb.chinfo);
	SET_TV_FINETUNE_PRE_DONE();
	CEepromGetTvFinetuneData(stTvInfo.CurChn, &ucTvFinetuneData);
}

//--------------------------------------------------
// Description  : Load default system data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadTvDataDefault(void)
{
	UINT8 i;
	//20071129
	UINT8 tvStatusBytes;
	
	stTvInfo = tEEPROM_TV_DATA;

	//CEepromWrite(_TV_CH_STATUS_ADDRESS, sizeof(StructTvChStatus), &stTvChStatus.ChStatus[0]);
	//20070329, default channel is skip
#if 1//_CUSTOMER_CGT
	CEepromLoadTvChStatusDefault();
#else	//#if _CUSTOMER_CGT
	
	pData[0] = 0x00;
	//20071129
	//for (i=0; i<GET_TV_MAX_CH()/8; i++)
	tvStatusBytes = GET_TV_MAX_CH()/8;
	tvStatusBytes = 8 * tvStatusBytes;
	if (GET_TV_MAX_CH() > tvStatusBytes)
		tvStatusBytes = GET_TV_MAX_CH()/8 + 1;
	for (i=0; i<tvStatusBytes; i++)
	{
		//20070402
		CEepromWrite(_TVCH_STATUS_ADDRESS+i, 1, pData);
		stTvChStatus.ChStatus[i] = pData[0];
	}
	
#endif	//#if _CUSTOMER_CGT

	CEepromWrite(_TV_DATA_ADDRESS, sizeof(StructTvDataType), &stTvInfo.CurSigMode);
	CEepromLoadTvData();

#if 1//(_TV_SCAN_UPDATE_SUPPORT)
	stTvPdb=tEEPROM_TV_PDB;
	for (i=0; i<GET_TV_MAX_CH(); i++)
	{
		CEepromWrite(_TV_PDB_ADDR(i), sizeof(StructTvPdb), &stTvPdb.chinfo);
	}
#endif

//20070407, tv finetune data
	pData[0] = 50;	//50: finetune data default
	pData[1] = 50;
	pData[2] = 50;
	pData[3] = 50;
	pData[4] = 50;
	pData[5] = 50;
	pData[6] = 50;
	pData[7] = 50;
	//write 8bytes one time
	for (i=0; i<GET_TV_MAX_CH()/8; i++)
	{
		CEepromWrite(_TV_FINETUNE_DATA_ADDRESS+i*8, 8, &pData[0]);
	}
	//20071129
	tvStatusBytes = GET_TV_MAX_CH()/8;
	tvStatusBytes = 8 * tvStatusBytes;
	if (GET_TV_MAX_CH()>tvStatusBytes)
	{
		for (i=tvStatusBytes; i<GET_TV_MAX_CH(); i++)
		{
			CEepromWrite(_TV_FINETUNE_DATA_ADDRESS+i, 1, &pData[0]);
		}
	}

}

//--------------------------------------------------
// Description  : Save tAudioData data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveAudioData(void)
{
    CEepromWrite(_AUDIO_DATA_ADDRESS, sizeof(StructAudioDataType), &stAudioData.Mode);
}

/**
* CEepromLoadAudioData
* Load Audio data
* @param <none>
* @return {none}
*
*/
void CEepromLoadAudioData(void)
{
    CEepromRead(_AUDIO_DATA_ADDRESS, sizeof(StructAudioDataType), &stAudioData.Mode);
}

//--------------------------------------------------
// Description  : Load default system data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadAudioDataDefault(void)
{
    stAudioData = tEEPROM_AUDIO_DATA;
    CEepromSaveAudioData();
}

void CEepromGetTvPdbData(BYTE chn, UINT8 *st)
{
	if (chn >= GET_TV_MAX_CH())
		return;
	
	CEepromRead(_TV_PDB_ADDR(chn), sizeof(StructTvPdb), st);
}


//--------------------------------------------------
// Description  : save offset data of specific channel
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveTvPdbData(BYTE chn, UINT8 *offset)
{
	if (chn >= GET_TV_MAX_CH())
		return; 
	CEepromWrite(_TV_PDB_ADDR(chn), sizeof(StructTvPdb), (UINT8 *)offset);
}

#if _CUSTOMER_HPC
//--------------------------------------------------
// Description  : save TvAUDIO_SYSdata of specific channel ; //add by xyw 071113
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveTvAUDIO_SYSData(BYTE chn, UINT8 *offset)
{
	if (chn >= GET_TV_MAX_CH())
		return; 
	CEepromWrite(_TV_PDB_ADDR(chn), 1, (UINT8 *)offset);
}
#endif
//20070407, tv finetune data
void CEepromGetTvFinetuneData(BYTE chn, UINT8 *pFinetune)
{
	if (chn >= GET_TV_MAX_CH())
		return;
	
	CEepromRead(_TV_FINETUNE_DATA_ADDRESS+chn, 1, pFinetune);
}
void CEepromSaveTvFinetuneData(BYTE chn, UINT8 *pFinetune)
{
	if (chn >= GET_TV_MAX_CH())
		return; 
	CEepromWrite(_TV_FINETUNE_DATA_ADDRESS+chn, 1, pFinetune);
}
//----------------------------------------------------------------------------------------------------
#if(_MCU_TYPE == _MYSON_MTV512)
//--------------------------------------------------
// Description  : Load EDID data (MTV512)
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadEDIDData(void)
{
    CEepromRead(_EDID0_ADDRESS, 128, &MCU_DDCRAM_0[0]);
    CEepromRead(_EDID1_ADDRESS, 128, &MCU_DDCRAM_1[0]);
}

//--------------------------------------------------
// Description  : Load EDID data (MTV512)
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadEDIDDataDefault(void)
{
    CEepromWrite(_EDID0_ADDRESS, 128, &tEDID_TABLE_VGA[0]);
    CEepromWrite(_EDID1_ADDRESS, 128, &tEDID_TABLE_DVI[0]);
    CEepromLoadEDIDData();
}
#endif
#if 0   //yf_zhang mark it 2007-5-30 23:13
//----------------------------------------------------------------------------------------------------
//-----------------------------------------------------
//picoraudio 	0:PICStd
//			1:AudioStd
//
void CEepromSaveTVSystem(UINT8 chn,UINT8 picORAudio,UINT8 Value)
{
	BYTE mode;
	CEepromRead(_TV_SYSTEM_ADDRESS+chn/2, 1, &mode);
	if(chn%2)
		{
			if(!picORAudio)	
			   mode = mode&(~0x0C)|(Value<< 2);	//tvsystem;
			else
			   mode  =  mode &(~0x03)|Value;			//Audio
		}
	else
		{	if(!picORAudio)
			     mode  =  mode &(~0xC0) |(Value<<6);		//tvsystem
			else
			   mode  =  mode &(~0x30) |(Value<<4);		//audio
		}
	CEepromWrite(_TV_SYSTEM_ADDRESS+chn/2, 1, &mode);	// write TV color system 
	CTimerDelayXms(20);
}
#endif


#if (_PICT_EFFECT_SUPPORT)
void CEepromSavePictModeData(void)
{
    CEepromWrite(_PICT_MODE_DATA_ADDRESS, sizeof(StructPictModeType), &stPictMode.PictModeVGA);
}

void CEepromLoadPictModeData(void)
{
    CEepromRead(_PICT_MODE_DATA_ADDRESS, sizeof(StructPictModeType), &stPictMode.PictModeVGA);
}

void CEepromLoadPictModeDataDefault(void)
{
    stPictMode = tEEPROM_PICTMODE_DATA;
    CEepromWrite(_PICT_MODE_DATA_ADDRESS, sizeof(StructPictModeType), &tEEPROM_PICTMODE_DATA.PictModeVGA);
}
#endif

//--------------------------------------------------
// Description  : Save Ypbpr ADC data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveYPbPrData(void)
{
	//store one mode only, prefer to 720p@60hz
	CEepromWrite(_YPbPr_DATA_ADDRESS+/*stModeInfo.ModeCurr*/0*sizeof(StructYPbPrDataType), sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
	/*
	if (GET_INPUTSOURCE_TYPE()==_SOURCE_YPBPR)
	{
		if (stModeInfo.ModeCurr<_MAX_YPBPR_MODE)
		{
			CEepromWrite(_YPbPr_DATA_ADDRESS+stModeInfo.ModeCurr*sizeof(StructYPbPrDataType), sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
		}
	}
	*/
}

//--------------------------------------------------
// Description  : Load ADC data of YPbPr
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadYPbPrData(void)
{
	CEepromRead(_YPbPr_DATA_ADDRESS+/*stModeInfo.ModeCurr*/0*sizeof(StructYPbPrDataType), sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
	/*
	if (stModeInfo.ModeCurr<_MAX_YPBPR_MODE)
	{
		CEepromRead(_YPbPr_DATA_ADDRESS+stModeInfo.ModeCurr*sizeof(StructYPbPrDataType), sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
	}
	else
	{
		stYPbPrData.YPbPrGain[_RED] = 0x80;
		stYPbPrData.YPbPrGain[_GREEN] = 0x80;
		stYPbPrData.YPbPrGain[_BLUE] = 0x80;
		stYPbPrData.YPbPrOffset[_RED] = 0x80;
		stYPbPrData.YPbPrOffset[_GREEN] = 0x80;
		stYPbPrData.YPbPrOffset[_BLUE] = 0x80;
	}
	*/

}

//--------------------------------------------------
// Description  : Load default ADC data
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadYPbPrDataDefault(void)
{
	CEepromWrite(_YPbPr_DATA_ADDRESS, sizeof(StructYPbPrDataType), &tEEPROM_YPbPr_DATA.YPbPrGain[_RED]);
	stYPbPrData = tEEPROM_YPbPr_DATA;
	/*
	UINT8 i;
	for (i=0;  i<_MAX_YPBPR_MODE; i++)
	{
		CEepromWrite(_YPbPr_DATA_ADDRESS+i*sizeof(StructYPbPrDataType), sizeof(StructYPbPrDataType), &tEEPROM_YPbPr_DATA[i].YPbPrGain[_RED]);
	}
	CEepromLoadYPbPrData();
	*/
}
/*
void CEepromLoadYPbPrDataModeDefault(BYTE mode)
{
	//premier, add Ypbpr mode
	//CEepromWrite(_YPbPr_DATA_ADDRESS, sizeof(StructYPbPrDataType), &tEEPROM_YPbPr_DATA.YPbPrGain[_RED]);
	//stYPbPrData = tEEPROM_YPbPr_DATA;
	CEepromWrite(_YPbPr_DATA_ADDRESS+sizeof(StructYPbPrDataType)*mode, sizeof(StructYPbPrDataType)*mode, &tEEPROM_YPbPr_DATA[mode].YPbPrGain[_RED]);
	CEepromRead(_YPbPr_DATA_ADDRESS+sizeof(StructYPbPrDataType)*mode, sizeof(StructYPbPrDataType), &stYPbPrData.YPbPrGain[_RED]);
}
*/

#if _TIMER_SLEEP_HINT_SUPPORT


void CEepromSaveTimeData(void)
{
    CEepromWrite(_TIME_DATA_ADDRESS, sizeof(StructTimeDataType), &stTimeData.ucTimeHourStart);
}
void CEepromLoadTimeData(void)
{
    CEepromRead(_TIME_DATA_ADDRESS, sizeof(StructTimeDataType), &stTimeData.ucTimeHourStart);
}
void CEepromLoadTimeDataDefault(void)
{
	stTimeData = tEEPROM_TIME_DATA;
	CEepromSaveTimeData();
}

#endif	//#if _TIMER_SLEEP_HINT_SUPPORT


//--------------------------------------------------
// Description  : Save mode setting data, such as FirstAuto,
//                HPosition, VPosition, Clock and Phase.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromSaveModeDataYPbPr(BYTE ucMode)
{
	if (ucMode>=_MAX_YPBPR_MODE)
		return;
	CEepromWrite(_MODE_DATA_YPBPR_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto);
}

//--------------------------------------------------
// Description  : Load mode setting data, such as FirstAuto,
//                HPosition, VPosition, Clock and Phase.
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromLoadModeDataYPbPr(BYTE ucMode)
{
	if (ucMode>=_MAX_YPBPR_MODE)
		return;
	
	if (CEepromRead(_MODE_DATA_YPBPR_ADDRESS + (WORD)ucMode * 8, sizeof(StructModeUserDataType), &stModeUserData.FirstAuto) == _FAIL)
	{
		stModeUserData.FirstAuto    = 0;
		stModeUserData.HPosition    = stModeInfo.IHStartPos;
		stModeUserData.VPosition    = stModeInfo.IVStartPos;
		stModeUserData.Clock        = stModeInfo.IHTotal;
		stModeUserData.Phase        = 0;
	}
}

//--------------------------------------------------
// Description  : Initial mode setting data with defaults
// Input Value  : None
// Output Value : None
//--------------------------------------------------
void CEepromInitialModeDataYPbPr(void)
{
	BYTE modecnt;

	for(modecnt=0;modecnt<_MAX_YPBPR_MODE;modecnt++)
	{
		stModeUserData.FirstAuto    = 0;
		//stModeUserData.HPosition    = tYPBPR_MODE_TABLE[modecnt].IHStartPos;
		//stModeUserData.VPosition    = tYPBPR_MODE_TABLE[modecnt].IVStartPos;
		//stModeUserData.Clock        = tYPBPR_MODE_TABLE[modecnt].IHTotal;
		stModeUserData.HPosition    = CYpbprGetTableData(modecnt, sPC_IHStartPos);
		stModeUserData.VPosition    = CYpbprGetTableData(modecnt, sPC_IVStartPos);
		stModeUserData.Clock        = CYpbprGetTableData(modecnt, sPC_IHTotal);
		stModeUserData.Phase        = 0;
		CEepromSaveModeDataYPbPr(modecnt);
	}
}

#if _SHARPNESS_REWRITE
//20080213
void CEepromSavePeakingCoringData(void)
{
    CEepromWrite(_PEAKING_DATA_ADDRESS, sizeof(StructPeakingCoringType), &stPeakingCoringData.PeakingCoringVGA);
}

void CEepromLoadPeakingCoringData(void)
{
    CEepromRead(_PEAKING_DATA_ADDRESS, sizeof(StructPeakingCoringType), &stPeakingCoringData.PeakingCoringVGA);
}

void CEepromLoadPeakingCoringDataDefault(void)
{
    stPeakingCoringData = tEEPROM_PEAKING_DATA;
    CEepromWrite(_PEAKING_DATA_ADDRESS, sizeof(StructPeakingCoringType), &tEEPROM_PEAKING_DATA.PeakingCoringVGA);
}
#endif	//#if _SHARPNESS_REWRITE


#if _FLASH_PROTECT_SUPPORT   //090427

#define _CMD_WRSR				0x01
#define _CMD_RDSR				0x05

BYTE CFlashReadStatusByte(void)
{
	MCU_COMMON_INST_EN_FF60 = 0x5A;	//Common instruction, Read Num = 1
	MCU_COMMON_OP_CODE_FF61 = _CMD_RDSR;	//Read status
	MCU_COMMON_INST_EN_FF60 |= 0x01;	//Common instruction enable
	
	while ((MCU_COMMON_INST_EN_FF60 & 0x01) == 0x01) 
	{ ; }

	return MCU_COMMON_INST_RD_PT0_FF67;
}

void CFlashWriteStatusByte(unsigned char status)
{
	MCU_COMMON_INST_EN_FF60 = 0x68;		//Write after WREN & Write_No=1
	MCU_COMMON_OP_CODE_FF61 = _CMD_WRSR;		//Instruction Code(WRSR:0x01)
	MCU_FLASH_PROG_ISP0_FF64 = status;//		//write byte(SRWD=1) 
	MCU_COMMON_INST_EN_FF60 |= 0x01;		//com_inst_en
}

#endif