nv_functions.c

GM5621原代码

//***************************************************************
// FUNCTION     :   InitColorTempSettings
// USAGE        :   Initialize color temperature setting in NVRAM
// DESCRIPTION  :
// INPUT        :   B_IsCheckPassed
// OUTPUT       :   none
// GLOBALS      :   none
// USED_REGS    :   None
//***************************************************************
#ifdef Genesis_REF_OSD
extern BYTE ROM ColorTempConst[8][3];   //defined in adjust.c
#endif

void far InitColorTempSettings (BYTE B_IsCheckPassed)
{
//   SBYTE B_CntColorTemp = NumOfColorTempEntries - 1;      // Modify for wrong color temp index using
   SBYTE B_CntColorTemp = 0;     // Modify for wrong color temp index using

   ColorTempType S_ColorTemp;
   gmt_RET_STAT ret;

	if(B_IsCheckPassed)
		ret = gm_ReadNVRAMBlock(ColorTemp_ID, 0, (BYTE *)&S_ColorTemp, 0, sizeof(ColorTempType));  //to read the 1st entry
	else
		ret = gmd_FAIL;

#if NVRAM_USE_FLASH && FAST_FLASH_PAGE_UPDATE
   if(ret!=gmd_OK)
	{

		BYTE B_Buffer[FLASH_PAGE_SIZE];
		WORD W_Length, W_HeaderSize, W_Addr;
      BYTE B_entryNumPerTime, B_StartIndex, i;

		W_HeaderSize = sizeof(block_hdr_type);

		msg("InitColorTempSettings in Nvram with ROM defaults", 0);


      //look up entry
      _fmemset(&B_Buffer, 0xff, FLASH_PAGE_SIZE);
   	W_Length = sizeof(ColorTempType);
      B_entryNumPerTime = FLASH_PAGE_SIZE / (W_HeaderSize+W_Length);
      W_Addr = W_HeaderSize;
      B_StartIndex = 0;
      i = 0;
		do
		{
			S_ColorTemp.R = ColorTempConst[B_CntColorTemp][0];
			S_ColorTemp.G = ColorTempConst[B_CntColorTemp][1];
			S_ColorTemp.B = ColorTempConst[B_CntColorTemp][2];

	      _fmemcpy(&B_Buffer[W_Addr], (BYTE *)&S_ColorTemp, W_Length);
         W_Addr += (W_Length + W_HeaderSize);

         //update data to flash
         if( (!((i+1)%B_entryNumPerTime)) || (i==NumOfColorTempEntries-1) )
         {
         	gm_ClearNVRAMBlock(ColorTemp_ID, B_StartIndex, (i%B_entryNumPerTime)+1, B_Buffer, W_Length);
		      W_Addr = W_HeaderSize;
            B_StartIndex += B_entryNumPerTime;
         }

         i++;   //update
//		} while(B_CntColorTemp--);
		} while((NumOfColorTempEntries-1) > B_CntColorTemp++);    // Modify for wrong color temp index using
  }

#else

   if(ret!=gmd_OK)
   {
		msg("InitColorTempSettings in Nvram with ROM defaults", 0);
		do
		{
			S_ColorTemp.R = ColorTempConst[B_CntColorTemp][0];
			S_ColorTemp.G = ColorTempConst[B_CntColorTemp][1];
			S_ColorTemp.B = ColorTempConst[B_CntColorTemp][2];

			SaveColorTemp (B_CntColorTemp, (BYTE *) &S_ColorTemp);
//		} while(B_CntColorTemp--);
		} while((NumOfColorTempEntries-1) > B_CntColorTemp++);    // Modify for wrong color temp index using
   }
#endif
}
//***************************************************************
// FUNCTION     :   LoadColorTemp
// USAGE        :   Read Color Temperature Data from NVRAM
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   none
// GLOBALS      :   none
// USED_REGS    :   None
//***************************************************************
void LoadColorTemp (BYTE B_Index, BYTE * Bp_Dest)
{
	gm_ReadNVRAMBlock(ColorTemp_ID, B_Index, (BYTE *) Bp_Dest, 0, sizeof(ColorTempType));
}

//***************************************************************
// FUNCTION     :   SaveColorTemp
// USAGE        :   Save Color Temperature Data in NVRAM
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   none
// GLOBALS      :   none
// USED_REGS    :   None
//***************************************************************
void SaveColorTemp (BYTE B_Index, BYTE * Bp_Dest)
{
	gm_WriteNVRAMBlock(ColorTemp_ID, B_Index, (BYTE *) Bp_Dest, 0, sizeof(ColorTempType));
}
#endif	// ColorTemp_WB_Used



//***************************************************************
// FUNCTION     :   CheckColorTemp
// USAGE        :   Check whether Color Temperature Data is in NVRAM
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   gmd_TRUE if stored in NVRAM
//					gmd_FALSE if not stored in NVRAM
// GLOBALS      :   none
// USED_REGS    :   None
//***************************************************************
#if UNUSED && 0
BYTE CheckColorTemp (void)
{
	BYTE B_CntColorTemp = MaxNumOfColorTemp;
	ColorTempType	S_ColorTemp;

	while(B_CntColorTemp--)
	{
		if(gm_ReadNVRAMBlock(ColorTemp_ID, B_CntColorTemp, (BYTE *) &S_ColorTemp, 0, sizeof(ColorTempType)) != gmd_OK)
			return gmd_FALSE;
	}
	return gmd_TRUE;
}
#endif

//***************************************************************
// FUNCTION     :   SaveSystemInfoToNVRAM
// INPUT        :   None
// OUTPUT       :   None
// USED_REGS    :   None
//***************************************************************
void SaveSystemInfoToNVRAM(void)
{
#ifdef	NVRAM_BLOCK_SystemInfo_WB_Used
	SystemInfo.B_LastActivePort = gmvb_CurrentPortMain;
	gm_WriteNVRAMBlock(SystemInfo_ID, 0, (BYTE *)&SystemInfo, 0, sizeof(SystemInfoNVRAMType));
#endif	// SystemInfo_WB_Used
}
//***************************************************************
// FUNCTION     :   RestoreSystemInfoFromNVRAM
// INPUT        :   BYTE B_IsCheckPassed -- is integrity check passed
// OUTPUT       :   None
// USED_REGS    :   None
//***************************************************************
void RestoreSystemInfoFromNVRAM(BYTE B_IsCheckPassed)
{
	if(!B_IsCheckPassed)
	{
		gmvb_CurrentPortMain = 0;
		SaveSystemInfoToNVRAM();
		return;
	}
#ifdef	NVRAM_BLOCK_SystemInfo_WB_Used
	if(gm_ReadNVRAMBlock(SystemInfo_ID, 0, (BYTE *)&SystemInfo, 0, sizeof(SystemInfoNVRAMType)) != gmd_OK)
	{
		SystemInfo.B_LastActivePort = 0;
		gmvb_CurrentPortMain = 0;
		return;
	}

	gmvb_CurrentPortMain = SystemInfo.B_LastActivePort;
	if(gmvb_CurrentPortMain > GetMaxPortNumber())
		gmvb_CurrentPortMain = 0;

#endif	// SystemInfo_WB_Used

}


//***************************************************************
// FUNCTION     :   SaveFactoryDependentSettings
// USAGE        :   Save Factory user preferred
//                  settings to NVRam
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   None
// GLOBALS      :   FactoryMenuGlobalsUserPreferences
// USED_REGS    :   None
//***************************************************************
#ifdef	NVRAM_BLOCK_FactoryDependentEntry_WB_Used
void SaveFactoryDependentSettings(void)
{
	gm_WriteNVRAMBlock(FactoryDependentEntry_ID, 0, (BYTE *) &FactoryMenuGlobalsUserPreferences, 0, sizeof(FactoryMenuGlobalsUserPrefType));
	 msg("Save Factrory Dep. Entry to NVRAM", 0);
}
#endif

//***************************************************************
// FUNCTION     :   ReadFactoryDependentSettings
// USAGE        :   Read Facoty dependent user prefered settings
// DESCRIPTION  :
// INPUT        :   None
// OUTPUT       :   None
// GLOBALS      :   FactoryMenuGlobalsUserPreferences
// USED_REGS    :   None
//***************************************************************
#ifdef	NVRAM_BLOCK_FactoryDependentEntry_WB_Used
void ReadFactoryDependentSettings(void)
{
	if( gm_ReadNVRAMBlock(FactoryDependentEntry_ID, 0, (BYTE *) &FactoryMenuGlobalsUserPreferences, 0, sizeof(FactoryMenuGlobalsUserPrefType)) != gmd_OK)
	{
		InitFactoryDependentSettings() ;
		SaveFactoryDependentSettings();
	}
}
#endif


#if defined(NVRAM_BLOCK_IntegrityCheck_WB_Used) && USE_NVRAM_INTEGRITY_CHECK
BYTE GetIntegrityCheckSettings(void)
{
	if(gm_ReadNVRAMBlock(IntegrityCheck_ID, 0, (BYTE *)&IntegrityCheckUserPreferences, 0, sizeof(IntegrityCheckUserPreferences)) != gmd_OK)
		return gmd_FALSE;

	msg("Read build ver. from NVRAM: 0x%x", IntegrityCheckUserPreferences.BuildVersion);

	return ((IntegrityCheckUserPreferences.BuildVersion == BUILD_NUMBER) ? gmd_TRUE : gmd_FALSE);
}

void SaveIntegrityCheckSettings(void)
{
	IntegrityCheckUserPreferences.BuildVersion = BUILD_NUMBER; // use generated value

	msg("Save build ver. to NVRAM: 0x%x", IntegrityCheckUserPreferences.BuildVersion);

	gm_WriteNVRAMBlock(IntegrityCheck_ID, 0, (BYTE *)&IntegrityCheckUserPreferences, 0, sizeof(IntegrityCheckUserPreferences));    

}
#endif

#ifdef Action_SaveAdjuster_WB_Used
void far SaveAdjuster(void)
{
	WORD 						W_Offset;
	AdjusterPropertyEntry ROM*		Bp_CurrentOffset;
	BYTE 						B_Ctrl;
	BYTE 						* Bp_CurrentAdjValue;
	//BYTE ROM 					* Bp_AdjusterRoutine;
	gmt_RET_STAT  				ret;
	size_t						adjusterSize;


	W_Offset 			= (gm_OsdGetCurrentSATOffsetWord() & (~(BIT15|BIT14|BIT13)));
	Bp_CurrentOffset 		= (AdjusterPropertyEntry ROM *)&UserDefAdjusterProperty[W_Offset];
	B_Ctrl 				= Bp_CurrentOffset->ctrl;
	//Bp_CurrentAdjValue	= GetUserPrefPtr(B_Ctrl) + Bp_CurrentOffset->offset;	/* get pointer to current adjuster value */
	Bp_CurrentAdjValue	= ((BYTE*)UserPrefStructureDefenitions[VT_GROUP_IND(B_Ctrl)].ptr) + Bp_CurrentOffset->offset;
	//Bp_AdjusterRoutine	= (BYTE ROM *)AdjusterFuncSet[Bp_CurrentOffset->id];	/* get pointer to adjuster routine */
	adjusterSize			= ((B_Ctrl & VT_MASK_TYPE) >> 1) + 1;

	msgx("Save adjuster %d",W_Offset);
	msgx("Control tag: %x",B_Ctrl);

	switch(VT_GROUP_IND(B_Ctrl) << 2)
	{
		case VT_ModeIndependent:
		{
			WORD val = 0;

			ret = gm_WriteNVRAMBlock(ModeIndependentUserPreferences_ID,	0,  Bp_CurrentAdjValue, Bp_CurrentOffset->offset,  adjusterSize);

			if(ret != gmd_OK) msgx("Save mode independent adjuster failed with code %d",ret);
			else msgx("Save mode independent adjuster success",0);

			gm_ReadNVRAMBlock(ModeIndependentUserPreferences_ID, 0,  (BYTE*)&val, Bp_CurrentOffset->offset, adjusterSize);

			msgx("saved value %d", *Bp_CurrentAdjValue);
			msgx("read value %d", val);

			break;
		} /* case VT_ModeIndependent */

		case VT_ModeDependent:
		{
			ModeDependentDescrTypeUserPrefType Desk;
			BYTE index = B_InputSaveIndex;

			if(B_NvramModeType == USER_MODE)
         	msgx("Save mode dependent adjuster, user mode",0);
			else
         	msgx("Save mode dependent adjuster, preset mode",0);

			if(gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(Desk)) != gmd_OK)
			{
				msg("Error reading Descriptor block",0);
				if(Desk.NextUserModeNumber == 0xff)
				{
					// initialize user mode look up.
					InitModeDependentLookUp();
				}
#if 0
				if(!(Desk.PresetModeFlag.Initialized || Desk.PresetModeFlag.Overwrittenable))
				{
					//initialize preset mode look up.
					InitializePresetModes();
				}
#endif
				InitModeDependentDescr();

				//if descriptor still bad then return.
				if((ret = gm_ReadNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(Desk))) != gmd_OK)
				{
					msgx("Bad descriptor. Status %d ",ret);
					return;
				}
			}/* if */
			
			// If this mode has not been saved before.
			if (index == NonSavedModeLookUpIndex)
			{
				msgx("This mode has not been saved. Saving",0);
				//for user mode, save it in cyclic way
				switch(B_NvramModeType)
				{
				case USER_MODE:
					// Note: Cyclic update scheme is used when the table is full.
					index = Desk.NextUserModeNumber++;
					B_InputSaveIndex = index;
					Desk.NextUserModeNumber %= MaxNumOfUserModeLookUpEntry;//MaxNumOfUserModes;
					// (PDR#5150) Reconciliation with gsel description. AlekseyK
					gm_WriteNVRAMBlock(ModeDependentDescrType_ID, 0, (BYTE *) &Desk, 0, sizeof(Desk));
					msg("new saved mode lookup index=%d", index);
					SaveModeDependentLookUpEntry(index, B_NvramModeType);
					SaveModeDependentEntry(index, B_NvramModeType);
					break;
				case PRESET_MODE:
					//this may happen on factory reset which intentionally changes B_InputSaveIndex to  NonSavedModeLookUpIndex
					if(FindPresetMode(&index) == gmd_TRUE)
					{
						SaveModeDependentLookUpEntry(index, B_NvramModeType);
						SaveModeDependentEntry(index, B_NvramModeType);
						B_InputSaveIndex = index;
						break;						
					}
					break;
				default:;
				} /* switch */
			} /* if */
			else
			{
				NVBLOCK_ID 	blockType;
				WORD		val = 0;
				
				SaveModeDependentLookUpEntry(index, B_NvramModeType);

				if(B_NvramModeType == PRESET_MODE)
					blockType = PresetModeDependentEntry_ID;
				else if(B_NvramModeType == USER_MODE)
				blockType = UserModeDependentEntry_ID;
					else;

#if 0
					SaveModeDependentEntry(index, B_NvramModeType);

#else
				ret = gm_WriteNVRAMBlock(blockType, index,Bp_CurrentAdjValue, Bp_CurrentOffset->offset, adjusterSize);
				if(ret != gmd_OK)
            	msgx("Entry has not been saved. Operation failed. status %d ",ret);
				else
            	msgx("Entry has been saved. Operation success ",ret);
#endif
				//	ret = gm_ReadNVRAMBlock(blockType, index,(BYTE*)&val, Bp_CurrentOffset->offset, adjusterSize);
				ret = gm_ReadNVRAMBlock(blockType,B_InputSaveIndex,(BYTE*)&val,Bp_CurrentOffset->offset,adjusterSize);

				msgx("Read status: %d", ret);
				msgx("Save.blockType = %d",blockType);
				msgx("Save.B_InputSaveIndex = %d",B_InputSaveIndex);
				msgx("Save.Bp_CurrentAdjValue = %d",(WORD)Bp_CurrentAdjValue);
				msgx("Save.Bp_CurrentOffset->offset = %d",Bp_CurrentOffset->offset);
				msgx("Save.adjusterSize = %d",adjusterSize);
				msgx("saved value %d", *Bp_CurrentAdjValue);
				msgx("read value %d", val);

			} /* else */
			break;
		}	/* case VT_ModeDependent */
	} /* switch */
}
#endif //#ifdef Action_SaveAdjuster_WB_Used