mst705Ȧ

MST705源代码

        NVRam_WriteByte(BoardChkSumAddr, BoardVersion);
    }

}
#else

#define CS_ERR  _BIT0
#define VER_ERR  _BIT1

BYTE CheckFlashDataBlockError(BOOL Block)
{
    BYTE ErrorType;
    BYTE i;
    BYTE ucCheckSum;

    for(i=0;i<5;i++)
    {
    		ErrorType=0;
        if(!Block)
            mstLoadDisplayData(SFD_ADDRESS);
        else
            mstLoadDisplayData(SFD_ADDRESS+0x1000);

        ucCheckSum=usrCalCheckSum((BYTE *)&g_VideoSetting, VideoSettingSize - CheckSumSize);

        if(g_VideoSetting.Checksum!=ucCheckSum)
            ErrorType|=CS_ERR;

        if(g_VideoSetting.ucVersion!=VideoVersion)
            ErrorType|=VER_ERR;

        if(!ErrorType)
            break;
    }

    return ErrorType;
}


void ReadSetting(void)
{
    BYTE Block0Err;
    BYTE Block1Err;

	if(g_bFlashReadOK)
		return;

    Block0Err=CheckFlashDataBlockError(0);
    Block1Err=CheckFlashDataBlockError(1);

    if(Block0Err&&!Block1Err) //Block0 error, Block1 OK, restore Block1 to Block0
    {
  	    putstr("\r\nBlock0 Err!");
		SaveVideoSetting();
    }
    else if(!Block0Err&&Block1Err)
    {
  	    putstr("\r\nBlock1 Err!");
        CheckFlashDataBlockError(0);
		SaveVideoSetting();
    }
    else if(Block0Err&&Block1Err)
    {
  	    putstr("\r\nUpdate!");
		InitVideoSetting();
		SaveVideoSetting();
    }
    else
    {
  	    putstr("\r\nLoad OK!");
    }

	g_bFlashReadOK=1;
}

#endif

//*******************************************************************
// Function Name: msSetUserPref
//
// Decscription: Restore user setting from NVRAM
//
// callee: msWriteByte() in ms_rwreg.c
//
// caller: msSetupMode() in mStar.c
//*******************************************************************
void msSetUserPref(void)
{
    BYTE tempSat,tempCon,tempBri;
    if(IsVideoPortInUse()||IsCCIR656InUse()/*||IsVGAInUse()*/)
    {
        msAdjustVideoRGB (RedGain, GreenGain, BlueGain);
        msAdjustVideoCbCr(CbGain, CrGain );

        tempBri=usrNonLinearCalculate(g_NLCBrightness,g_VideoSetting.VideoBrightness);
        msAdjustBrightness(tempBri);
        tempCon=usrNonLinearCalculate(g_NLCContrast,g_VideoSetting.VideoContrast);
        tempSat=usrNonLinearCalculate(g_NLCSaturation,g_VideoSetting.VideoSaturation);

#if TV_ENABLE
        if(IsTVInUse())
            tempCon+=TV_EXTR_CONTRAST;
#endif

        msAdjustHSC(g_VideoSetting.VideoHue, tempSat, tempCon);

        msAdjustVideoHue(g_VideoSetting.VideoHue);
    }
    #if YPBPR_ENABLE
    else if(IsYPbPrInUse())
    {
        msAdjustVideoRGB (RedGain, GreenGain, BlueGain);
        msAdjustVideoCbCr(CbGain, CrGain );

        tempSat=usrNonLinearCalculate(g_NLCSaturation,g_YPbPrSetting.Saturation);
        tempCon=usrNonLinearCalculate(g_NLCContrast,g_YPbPrSetting.Contrast);

        msAdjustHSC(50, tempSat, tempCon);

        msAdjustVideoHue(50);

        tempBri=usrNonLinearCalculate(g_NLCBrightness,g_YPbPrSetting.Brightness);
        msAdjustBrightness(tempBri);
    }
    #endif
    else
    {
        tempBri=usrNonLinearCalculate(g_NLCBrightness,g_PcSetting.Brightness);
        msAdjustBrightness(tempBri);
        tempCon=usrNonLinearCalculate(g_NLCContrast,g_PcSetting.Contrast);
        msAdjustPCContrast(tempCon);
    }
}

//**************************************************************************************************************//
#if TV_ENABLE
void EraseTvSkipInfo(void)
{
WatchDogClear();
 NVRam_WriteTbl(TV_SKIP_INFOAddr, g_ucTVChannelSkipInfoBuff, ((TV_MAX_CHANNEL_NUM+1)/8+1));
 #if TV_SYSTEM==TV_NTSC
 NVRam_WriteTbl(CATV_SKIP_INFOAddr, g_ucCATVChannelSkipInfoBuff, (CATV_MAX_CHANNEL_NUM+1)/8+1);
 #endif
}

void ReadChannelSkipInfoSetting(void)
{
WatchDogClear();
 NVRam_ReadTbl(TV_SKIP_INFOAddr, g_ucTVChannelSkipInfoBuff, (TV_MAX_CHANNEL_NUM+1)/8+1);
 #if TV_SYSTEM==TV_NTSC
 NVRam_ReadTbl(CATV_SKIP_INFOAddr, g_ucCATVChannelSkipInfoBuff, (CATV_MAX_CHANNEL_NUM+1)/8+1);
 #endif
}

#if TV_SYSTEM==TV_PAL
void EraseEepromTvFlag(BYTE StartChannal)
{
	BYTE channel;
	for(channel=StartChannal;channel<=TV_MAX_CHANNEL_NUM-1;channel++)
    {
		WatchDogClear();
		NVRam_WriteByte((nvrChanneAddr(channel)+MISCOFFSETADDR), (TV_SOUND_I|DoAFCFlag)& 0x8F);
    }
}
#endif

void CheckChannelNumberSettingRang()
{
#if TV_SYSTEM==TV_PAL
    g_TVChSetting.ucCurChannelNO %=TV_MAX_CHANNEL_NUM;
    g_TVChSetting.ucPreChannelNO %=TV_MAX_CHANNEL_NUM;
#else

    g_TVChSetting.ucTVSource%=NTSC_SOURCE_NUM;

    if(g_TVChSetting.ucTVSource==NTSC_ATV)
    	{
    	g_TVChSetting.ucCurChannelNO %=TV_MAX_CHANNEL_NUM;
    	g_TVChSetting.ucPreChannelNO %=TV_MAX_CHANNEL_NUM;

    	}
	else
	{
    	g_TVChSetting.ucCurChannelNO %=CATV_MAX_CHANNEL_NUM;
    	g_TVChSetting.ucPreChannelNO %=CATV_MAX_CHANNEL_NUM;
	}

    g_TVChSetting.ucATVChannelNO%=TV_MAX_CHANNEL_NUM;
    g_TVChSetting.ucCTVChannelNO%=CATV_MAX_CHANNEL_NUM;
#endif
    g_VideoSetting.TunerAGC%=0x20;
}

void ReadChannelNumberSetting(void)
{
    NVRam_ReadTbl(ChannelNumberInfoAddr, (BYTE*)&g_TVChSetting, ChannelNumberInfoSize);
    CheckChannelNumberSettingRang();
}

void SaveChannelNumberSetting(void)
{
  	NVRam_WriteTbl(ChannelNumberInfoAddr, (BYTE*)&g_TVChSetting, ChannelNumberInfoSize);
}
#endif

//**************************************************************************************************************//
#if(VGA_ENABLE||YPBPR_ENABLE)
void InitSaveModeFlag(void)
{
    NVRam_WriteByte(nvrMonitorAddr(Checksum), 0);

    for (g_ucSaveIndex=0; g_ucSaveIndex<NumberOfMode; g_ucSaveIndex++)
    {
        WatchDogClear();
        NVRam_WriteByte(nvrModeAddr(checksum), 0);
    }
}

void InitModeSetting(void)
{
    g_ModeSetting.HTotal=StandardModeHTotal;
    g_ModeSetting.HStart=StandardModeHStart;
    g_ModeSetting.VStart=StandardModeVStart;
    g_ModeSetting.AutoHStart=g_ModeSetting.HStart;
    g_ModeSetting.AutoVStart=g_ModeSetting.VStart;             //owen   110205
    g_ModeSetting.Phase=0x1F;
    g_ModeSetting.AutoTimes=0;
    g_ModeSetting.checksum=ModeCSValue;
}

void CheckModeSettingRange(void)
{
    if (abs(g_ModeSetting.HTotal-StandardModeHTotal)>ClockAdjRange)
        g_ModeSetting.HTotal=StandardModeHTotal;
    if (g_ModeSetting.HStart>2*StandardModeHStart)
        g_ModeSetting.HStart=StandardModeHStart;
    if (g_ModeSetting.VStart>2*StandardModeVStart)
        g_ModeSetting.VStart=StandardModeVStart;

    g_ModeSetting.Phase&=0x3F;

    if (g_ModeSetting.AutoTimes==0 || abs(g_ModeSetting.HStart-g_ModeSetting.AutoHStart)>50)
        g_ModeSetting.AutoHStart=g_ModeSetting.HStart;
}



void SaveModeSetting(void)
{
    NVRam_WriteTbl(nvrModeBaseAddr(g_ucSaveIndex), (BYTE*)&g_ModeSetting, ModeSettingSize);
}

void GetModeSaveIndex(void)
{
    ModeInfoType modeInfo;
    BYTE i;
    WORD hFreq, vFreq;

    hFreq=HFreq(SrcHPeriod);
    vFreq=VFreq(hFreq, SrcVTotal);
    for (i=0; i<UserModeNumber; i++)
    {
      NVRam_ReadTbl(nvrModeInfoAddr(i) , (BYTE*)&modeInfo, ModeInfoSize);
      if (abs(hFreq-modeInfo.HorFreq)<HFreq_Tol &&    abs(vFreq-modeInfo.VerFreq)<VFreq_Tol &&
      	  (SrcFlags&0x13)==modeInfo.Flags)
      break;
    }

    if (i>=UserModeNumber)
    {
        g_PcSetting.SavedModeIndex=(g_PcSetting.SavedModeIndex+1)%UserModeNumber;
        g_ucSaveIndex=g_PcSetting.SavedModeIndex;
        modeInfo.HorFreq=hFreq;
        modeInfo.VerFreq=vFreq;
        modeInfo.Flags=SrcFlags&0x13;
        NVRam_WriteTbl(nvrModeInfoAddr(g_ucSaveIndex), (BYTE*)&modeInfo, ModeInfoSize);
        NVRam_WriteByte(nvrModeAddr(checksum), 0);
        NVRam_WriteByte(nvrMonitorAddr(SavedModeIndex), g_PcSetting.SavedModeIndex);
    }
    else
        g_ucSaveIndex=i;
}

void ReadModeSetting(void)
{
    BYTE tempValue;
    if (UserModeFlag)
        GetModeSaveIndex();
    else
        g_ucSaveIndex=g_ucSrcModeIndex;

    NVRam_ReadByte(nvrModeAddr(checksum), &tempValue);

    if (tempValue==ModeCSValue)
    {
        NVRam_ReadTbl(nvrModeBaseAddr(g_ucSaveIndex), (BYTE*)&g_ModeSetting, ModeSettingSize);
    }
    else
    {
        InitModeSetting();
        SaveModeSetting();
    }

    CheckModeSettingRange();
}
#endif
//**************************************************************************************************************//