nv_functions.c

GM5621原代码

// INPUT        :   flag
// OUTPUT       :   flag
// GLOBALS      :   ModeDependentDescriptor
// USED_REGS    :   None
//***************************************************************
#if UNUSED && 0
static void __near ReadPresetModesFlag(PresetModeFlagUserPrefType* flag)
{
	ModeDependentDescrTypeUserPrefType Desk;

	gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));

	*flag = (PresetModeFlagUserPrefType)(Desk.PresetModeFlag);
}
#endif
//***************************************************************
// FUNCTION     :   SaveModeDependentEntry
// USAGE        :   Save the mode dependent setting
//                  to entry in NVRAM
// DESCRIPTION  :
// INPUT        :   index, type
// OUTPUT       :   None
// GLOBALS      :   ModeDependentUserPreferences
// USED_REGS    :   None
//***************************************************************
#ifdef	ModeDependent_Used
static void __near SaveModeDependentEntry(BYTE index, NVMODE_TYPE type)
{
	if(type==PRESET_MODE)
	{
		gm_WriteNVRAMBlock(PresetModeDependentEntry_ID, index, (BYTE *) &ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences));
		msg("SaveModeDep: PRESET_MODE entry %d", index);
	}
	else if(type==USER_MODE)
	{
		gm_WriteNVRAMBlock(UserModeDependentEntry_ID, index, (BYTE *) &ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences));
		msg("SaveModeDep: USER_MODE entry %d", index);
	}

   B_DDCCINewControlVal = 1; //Required only for DDCCI - To make DDCCI MCCS 2.0 Compliant - 14June04
   
	msgx("UserPrefHTotal = %d", UserPrefHTotal);
	msgx("UserPrefHStart = %d", UserPrefHStart);
	msgx("UserPrefVStart = %d", UserPrefVStart);
	msgx("UserPrefHSyncPhase = %d", UserPrefHSyncPhase);
	#ifdef UserPrefPhaseSkew
		msgx("UserPrefPhaseSkew = %x", UserPrefPhaseSkew);
	#endif

}
#endif

//***************************************************************
// FUNCTION     :   ClearModeDependentLookUpEntry
// USAGE        :   Clear the input timing tags to
//                  look up table in NVRAM.
// DESCRIPTION  :
// INPUT        :   index, type
// OUTPUT       :   None
// GLOBALS      :
// USED_REGS    :
//***************************************************************
#ifdef	ModeDependent_Used
static void __near ClearModeDependentLookUpEntry(BYTE index, NVMODE_TYPE type)
{
	ModeLookUpEntryTypeUserPrefType tmp;

	_fmemset(&tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));

	if(type == PRESET_MODE)
		gm_WriteNVRAMBlock(PresetModeLookUpEntry_ID, index, (BYTE *) &tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));
	else if(type == USER_MODE)
		gm_WriteNVRAMBlock(UserModeLookUpEntry_ID, index, (BYTE *) &tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));
	else;
}
#endif

//***************************************************************
// FUNCTION     :   FindPresetMode
// USAGE        :   Checks to see if current mode is a preset mode.
// INPUT        :   pointer to return value index, which will be the index
// 					  into the Preset Mode table
// OUTPUT       :   gmd_TRUE if entry is a Preset Mode else gmd_FALSE
//***************************************************************
#ifdef	ModeDependent_Used
gmt_RET_STAT FindPresetMode(BYTE *index)
{
	BYTE i;
	// first see if current mode is a Preset Mode or a User mode.
	for(i=0;i<MaxNumOfPresetModeLookUpEntry;i++)
	{
		if ((abs(StandardModeTable[i].StdHFreq - gmvw_InputHFreqMain) <= StandardModeTable[i].DeltaHFreq) &&
			(abs(StandardModeTable[i].StdVTotal - gmvw_InputVTotalMain) <= StandardModeTable[i].DeltaVTotal))
		{
         // Merlin 0824, add sync polarity checking for preset mode check
			if((StandardModeTable[i].ModeType & gmd_SYNC_POL_MASK) == (gmvw_InputFlagsMain & gmd_SYNC_POL_MASK))
			{
			msg("FindPresetMode: PRESET MODE %d",i);
			*index = i;
			return gmd_TRUE;
		}
	}
	}
	return gmd_FALSE;
}
#endif //ModeDependent_Used
//***************************************************************
// FUNCTION     :   ReadModeDependentEntry
// USAGE        :   Read mode dependent user preferred
//                  settings by index from NVram
// DESCRIPTION  :
// INPUT        :   void
// OUTPUT       :   gmd_TRUE if nvram entry found and CRC match
//                  gmd_FALSE if current mode not found in NVRAM or
//						  calculated CRC don't match with
//                  nvram CRC.
// GLOBALS      :   ModeDependentUserPreferences
// USED_REGS    :   None
//***************************************************************
gmt_RET_STAT ReadModeDependentEntry(void)
{
#ifdef	ModeDependent_Used
	BYTE i;
	ModeLookUpEntryTypeUserPrefType savedIFM;
	BYTE type = USER_MODE;

	// first see if current mode is a Preset Mode or a User mode.
	if(FindPresetMode(&i))
	{
		type = PRESET_MODE;
		msg("ReadModeDep: PRESET MODE %d",i);
	}
	// Now if it's a Preset Mode, i points to the preset mode index, otherwise
	// if it's a User Mode, we're going to have to search the User Mode
	// entries in NVRAM.
	if(type == USER_MODE)
	{
		for(i=0;i<MaxNumOfUserModeLookUpEntry;i++)
		{
			gm_ReadNVRAMBlock(UserModeLookUpEntry_ID, i, (BYTE *)&savedIFM, 0, sizeof(ModeLookUpEntryTypeUserPrefType));

			msgx("savedIFM.Tags.HFreq = %d", savedIFM.Tags.HFreq);
			msgx("savedIFM.Tags.VFreq = %d", savedIFM.Tags.VFreq);
			msgx("savedIFM.Tags.VTotal = %d", savedIFM.Tags.VTotal);
			msgx("savedIFM.SyncPolarity = 0x%x", savedIFM.SyncPolarity);

			if (savedIFM.Tags.HFreq == 0 || savedIFM.Tags.VFreq == 0 || savedIFM.Tags.VTotal == 0)
			{
				return gmd_FAIL; //EndOfLookUpIndex;
			}

			if ((abs(savedIFM.Tags.HFreq - gmvw_InputHFreqMain) <= SavedHFreqDelta) &&
				(abs(savedIFM.Tags.VFreq - gmvw_InputVFreqMain) <= SavedVFreqDelta) &&
				(abs(savedIFM.Tags.VTotal - gmvw_InputVTotalMain) <= SavedVTotalDelta))
			{
				if(savedIFM.SyncPolarity == (gmvw_InputFlagsMain & gmd_SYNC_POL_MASK))
				{
					msg("ReadModeDep: USER MODE %d",i);
					break;
				}
			}
		}// for i < MaxNumOfUserModeLookUpEntry
		if(i >= MaxNumOfUserModeLookUpEntry)
		{
			msg("ReadModeDep: Mode not found",0);
			return gmd_FAIL; // it's not a preset mode, and it's not a user mode.
		}
	}// if USER_MODE

	// At this point 'type' is PRESET_MODE or USER_MODE, and 'i' is the index
	// of that mode.
	if(type == PRESET_MODE)
	{
#if	DEBUG_MSG && DEBUG_NVRAM
		BYTE ret;
		if((ret = gm_ReadNVRAMBlock(PresetModeDependentEntry_ID, i, (BYTE *) &ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences))) != gmd_OK)
#else
		if(gm_ReadNVRAMBlock(PresetModeDependentEntry_ID, i, (BYTE *) &ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences)) != gmd_OK)
#endif
		{
			msg("gm_ReadNVRAMBlock fail on PRESET_MODE %x",ret);
			return gmd_FAIL;
		}
	}
	else
	{
		if(gm_ReadNVRAMBlock(UserModeDependentEntry_ID, i, (BYTE *) &ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences)) != gmd_OK)
		{	// Clear this entry.
			msg("gm_ReadNVRAMBlock fail on USER_MODE",0);
			_fmemset(&ModeDependentUserPreferences, 0, sizeof(ModeDependentUserPreferences));
			SaveModeDependentEntry(i, type);
			ClearModeDependentLookUpEntry(i, type);
			return gmd_FAIL;
		}
	}

	msgx("UserPrefHTotal = %d", UserPrefHTotal);
	msgx("UserPrefHStart = %d", UserPrefHStart);
	msgx("UserPrefVStart = %d", UserPrefVStart);
	msgx("UserPrefHSyncPhase = %d", UserPrefHSyncPhase);
	#ifdef UserPrefPhaseSkew
	msgx("UserPrefPhaseSkew = %x", UserPrefPhaseSkew);
	#endif

	B_InputSaveIndex = i;

	return gmd_OK;
#else
	return gmd_FAIL; // if ModeDependent_Used not defined.
#endif //ModeDependent_Used
}

//***************************************************************
// FUNCTION     :   SaveModeDependentLoopUpEntry
// USAGE        :   Save the input timing tags to
//                  look up table in NVRAM
// DESCRIPTION  :
// INPUT        :   index, type
// OUTPUT       :   None
// GLOBALS      :   InputFormat
//                  ModeDependentLookUpStart
//                  ModeDependentLookUpSize
// USED_REGS    :   None
//***************************************************************
#ifdef	ModeDependent_Used
static void __near SaveModeDependentLookUpEntry(BYTE index, NVMODE_TYPE type)
{
	ModeLookUpEntryTypeUserPrefType tmp;

	if(type == PRESET_MODE)
	{
		gm_ReadNVRAMBlock(PresetModeLookUpEntry_ID, index, (BYTE *) &tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));

		tmp.Tags.HFreq = StandardModeTable[InputPortArray[IP_RGB].StdModeArray[index]].StdHFreq;
		tmp.Tags.VTotal = StandardModeTable[InputPortArray[IP_RGB].StdModeArray[index]].StdVTotal;
		tmp.Tags.VFreq = (WORD)(((DWORD)(tmp.Tags.HFreq*1000l))/((DWORD)(tmp.Tags.VTotal)));
		tmp.SyncPolarity = (gmvw_InputFlagsMain & gmd_SYNC_POL_MASK); // | SyncPolaritySavedMask;

		gm_WriteNVRAMBlock(PresetModeLookUpEntry_ID, index, (BYTE *) &tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));
	}
	else if(type == USER_MODE)
	{
		tmp.Tags.HFreq = gmvw_InputHFreqMain;
		tmp.Tags.VFreq = gmvw_InputVFreqMain;
		tmp.Tags.VTotal = gmvw_InputVTotalMain;
		tmp.SyncPolarity = (gmvw_InputFlagsMain & gmd_SYNC_POL_MASK);
		gm_WriteNVRAMBlock(UserModeLookUpEntry_ID, index, (BYTE *) &tmp, 0, sizeof(ModeLookUpEntryTypeUserPrefType));
	}
	else;
}
#endif




//***************************************************************
// FUNCTION     :   SaveModeDependentSettings
// USAGE        :   Save mode dependent user preferred
//                  settings by index to NVRam
// DESCRIPTION  :
// INPUT        :   index
// OUTPUT       :   None
// GLOBALS      :   ModeDependentDescriptor
// USED_REGS    :   None
//***************************************************************
void SaveModeDependentSettings(void)
{
#ifdef	ModeDependent_Used
	ModeDependentDescrTypeUserPrefType Desk;
	BYTE index = B_InputSaveIndex;
   gmt_RET_STAT ret;

	// see if this is a preset mode, if so just update the preset mode entry.
	if(FindPresetMode(&index))
	{
		SaveModeDependentLookUpEntry(index, PRESET_MODE);
		SaveModeDependentEntry(index, PRESET_MODE);
		B_InputSaveIndex = index;
		return;
	}

   ret = gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));
	msgx("ret = %d", ret);
   
	if(ret != gmd_OK || Desk.NextUserModeNumber > MaxNumOfUserModeLookUpEntry)
	{
		msg("Error reading Descriptor block",0);
		if(Desk.NextUserModeNumber == 0xff)
		{
			// initialize user mode look up.
			InitModeDependentLookUp();
		}
		if(!(Desk.PresetModeFlag.ModeFlag & InitializedBitMask) )
      {
			//initialize preset mode look up.
			InitializePresetModes(gmd_TRUE);
		}

		InitModeDependentDescr();
	}

	//if descriptor still bad then return.
	if(gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType)) != gmd_OK)
		return;

	// If a User Mode, see if this mode has been saved before.
	if (index == NonSavedModeLookUpIndex)
	{// Note: Cyclic update scheme is used when the table is full.
		index = Desk.NextUserModeNumber++;
		B_InputSaveIndex = index;
		Desk.NextUserModeNumber %= MaxNumOfUserModeLookUpEntry;

		msgx("SaveModeDep: NextUserModeNum = %d", Desk.NextUserModeNumber);
		// (PDR#5150) Reconciliation with gsel description. AlekseyK
		gm_WriteNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));
		msgx("new saved mode lookup index=%d", index);
	}

	SaveModeDependentLookUpEntry(index, USER_MODE);
	SaveModeDependentEntry(index, USER_MODE);
#endif
}

//***************************************************************
// FUNCTION     :   InitModeDependentDescr
// USAGE        :   Initialize mode dependent descriptor
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   None
// GLOBALS      :   ModeDependentDescriptor
// USED_REGS    :   None
//Note: this is only initialze for USER_MODE only
//***************************************************************
#ifdef	ModeDependent_Used
void InitModeDependentDescr(void)
{
	ModeDependentDescrTypeUserPrefType Desk;

	msg("Init mode dep. descriptor", 0);

	gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));
	Desk.NextUserModeNumber = 0;
	gm_WriteNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));
}
#endif

//***************************************************************
// FUNCTION     :
// USAGE        :   Initialize mode dependent timing
//                  tags look up table
// DESCRIPTION  :
// INPUT        :   type
// OUTPUT       :   None
// GLOBALS      :   ModeDependentLookUpStart
//                  ModeDependentLookUpSize
// USED_REGS    :   None
//***************************************************************
#ifdef	ModeDependent_Used
void InitModeDependentLookUp(void)
{
	// Speed up for page-write type of flash like PMC by collecting all blocks of a same type together and
	// issue only one flash write command instead of number of MaxNumOfUserModeLookUpEntry times.
	#if NVRAM_USE_FLASH && FAST_FLASH_PAGE_UPDATE

	// Important: Buffer must includes NVRAM block header.
	BYTE B_Buffer[(sizeof(block_hdr_type)+sizeof(ModeLookUpEntryTypeUserPrefType)) * MaxNumOfUserModeLookUpEntry];
	WORD W_Length, W_HeaderSize;

	W_HeaderSize = sizeof(block_hdr_type);
      	W_Length = sizeof(ModeLookUpEntryTypeUserPrefType);

      	_fmemset(&B_Buffer, 0, (W_Length+W_HeaderSize) * MaxNumOfUserModeLookUpEntry);

	// Calls function to clear blocks of a same type more efficiently (especially for page-write type of flash like PMC).
	// Still passes the original block size (not includes header).
      	gm_ClearNVRAMBlock(UserModeLookUpEntry_ID, 0, MaxNumOfUserModeLookUpEntry, (BYTE *) B_Buffer, W_Length);

	#else

	BYTE i;
	NVMODE_TYPE type;
	ModeDependentDescrTypeUserPrefType Desk;

	msg("Init mode dep. timing tags", 0);

	gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(ModeDependentDescrTypeUserPrefType));

	type = USER_MODE;
	i = MaxNumOfUserModeLookUpEntry;

	while(i--)
		ClearModeDependentLookUpEntry(i, type);
	#endif // NVRAM_USE_FLASH && FAST_FLASH_PAGE_UPDATE
}
#endif

#ifdef	NVRAM_BLOCK_ColorTemp_WB_Used