mst705Ȧ

MST705源代码

#define _DETECT_C_

#include <math.h>
#include "types.h"
#include "board.h"
#if(VGA_ENABLE||YPBPR_ENABLE)
#include "global.h"
#include "ms_reg.h"
#include "ms_rwreg.h"
#include "power.h"
#include "DEBUG.h"
#include "misc.h"
#include "menu.h"
#include "UserPref.h"
#include "msOSD.h"
#include "panel.h"
#include "mStar.h"
#include "DevVD.h"
#include "detect.h"
#include "Menufunc.h"
#include "mstar.h"
#include "Adjust.h"


#if(VGA_ENABLE||YPBPR_ENABLE)
void msSetBK0_0D(BYTE Value);
#endif
void Menu_InitAction(void)
{
    if (SyncLossState())
    {
        /*if(FactoryModeFlag)
            g_ucMenuPageIndex=FactoryRootMenu;
        else*/
            g_ucMenuPageIndex=StandbyMenu;
    }
    else if (UnsupportedModeFlag)
    {
        g_ucMenuPageIndex=UnsupportedModeMenu;
    }
    else if (g_ModeSetting.AutoTimes==0 )
    {
        if(IsVGAInUse())
            g_ucMenuPageIndex=AutoMenu;
        else
            g_ucMenuPageIndex=RootMenu;
    }
    else
    {
        g_ucMenuPageIndex=RootMenu;
    }

    if(FactoryModeFlag) //hyy 2007 01 26
        g_ucMenuPageIndex=FactoryRootMenu;

    g_ucMenuItemIndex=0;
    g_ucOsdCounter=0;
    ExecuteKeyEvent(MIA_RedrawMenu);
    WatchDogClear();

    //AutoConfig();
    if (UnsupportedModeFlag)
    {
        if(!FreeRunModeFlag)
        {
            if (g_ModeSetting.AutoTimes	==0 )
            AutoConfig();
        }
    }
}
//*******************************************************************
// Function Name: msMonitorInputTiming
//
// Decscription: Detect input timing
//
// callee: msSyncLossStateDetect(), msValidTimingDetect(), msAutoDVI() in detect.c
//         msSetInputPort(),  in mstar.c
//
// caller: main() in main.c
//*******************************************************************
void msMonitorInputTiming(void)
{
    if (!PowerOnFlag)
        return;

#if Enable_Logo_Display
    if(DrawLogoFlag)
        return;
#endif

    // detect whether input signal is changing
    if (!g_bInputTimingChangeFlag)
    {
        if (SyncLossState())
        {
            if (!FreeRunModeFlag)
            {
                //printMsg("!FreeRunModeFlag");
                Set_InputTimingChangeFlag();
            }
            else if (msSyncLossStateDetect()) // detect mode while no Sync/suspend/standby/disconnect
            {
                //printMsg("msSyncLossStateDetect");
                Set_InputTimingChangeFlag();
            }
        }
        else // valid timing
        { // check if input timing is changing
            if (msValidTimingDetect())
            { 
                //printMsg("msValidTimingDetect");
                SrcFlags|=SyncLoss;
                Set_InputTimingChangeFlag();
            }
        }
    }

  //=============================================================================
  //=============================================================================
    if (g_bInputTimingChangeFlag) // input timing is unstable
    {
        Clr_InputTimingChangeFlag();
        Clr_DoModeSettingFlag();
        g_ucTimingChangeDebunce++;
        if (!SyncLossState())// && !InputTimingStableFlag) // prevent from SOG
        {
            if (g_ucTimingChangeDebunce<=3)
            {
                SrcFlags|=SyncLoss;
                return;
            }
        }
        msPrepareForTimingChange();
        //printMsg("VGA InputTimingChange");
    }
    else // input timing is stable
    {
        g_ucTimingChangeDebunce=0;
        g_ucInputTimingStableCounter++; // counter timing stable times
        if (g_ucInputTimingStableCounter==0)
            g_ucInputTimingStableCounter=1;
        if (!InputTimingStableFlag)
        {
            if ((!SyncLossState() && g_ucInputTimingStableCounter>=ValidTimingStableCount)|| // set timing stable flag
            (SyncLossState() && g_ucInputTimingStableCounter>=SyncLossStableCount))
            {
                Set_InputTimingStableFlag();// set flag to search for input mode
                Set_DoModeSettingFlag();
            }
        }
    }
}


//*******************************************************************
// Function Name: msModeHandler
//
// Decscription: Programming scaler while input timing is changing
//
// callee: msSyncLossStateDetect(), msValidTimingDetect(), msAutoDVI() in detect.c
//         msSetInputPort(),  in mstar.c
//
// caller: main() in main.c
//*******************************************************************
void msModeHandler(void)
{
    if (!DoModeSettingFlag) // while timing change & stable
    {
        return;
    }    
    Clr_DoModeSettingFlag();

    if (!SyncLossState())
    {
        if (!msFindMode()) // search mode index
        {
            printMsg("mode find fail");
            Set_InputTimingChangeFlag(); // search mode faile
            return;
        }

        if (!UnsupportedModeFlag) //supported mode
        {
            printf("\r\ninput timing index = %d", g_ucSrcModeIndex);
			#if (VGA_ENABLE==0) 	//gan add
				g_ucSrcModeIndex +=29;
			#endif

			if(g_ucSrcModeIndex==6)	//640*480@60
				msSetBK0_0D(6);
			else if(g_ucSrcModeIndex==8)	//640*480@72
				msSetBK0_0D(6);
			else if(g_ucSrcModeIndex==9)	//640*480@75
				msSetBK0_0D(7);
			else if(g_ucSrcModeIndex==11||g_ucSrcModeIndex==12||g_ucSrcModeIndex==13||g_ucSrcModeIndex==14)	//800*600@56/60/72/75
				msSetBK0_0D(8);
			else if(g_ucSrcModeIndex==18||g_ucSrcModeIndex==19||g_ucSrcModeIndex==20)	//1024*768@60/70/75
				msSetBK0_0D(11);
			else if(g_ucSrcModeIndex==23||g_ucSrcModeIndex==24||g_ucSrcModeIndex==25)	//1280*960  / 1280*1024 / 1600*1200  @60Hz
				msSetBK0_0D(13);
		//================YPbPr=============================================			
			else if(g_ucSrcModeIndex==29)	//576i
				msSetBK0_0D(4);
			else if(g_ucSrcModeIndex==30)	//480i
				msSetBK0_0D(3);
			else if(g_ucSrcModeIndex==31)	//576P
				msSetBK0_0D(8);
			else if(g_ucSrcModeIndex==32)	//480P
				msSetBK0_0D(6);
			else if(g_ucSrcModeIndex==33||g_ucSrcModeIndex==34)	//720P  @50Hz//@60Hz
				msSetBK0_0D(10);
			else if(g_ucSrcModeIndex==35)	//1080i  @50Hz
				msSetBK0_0D(7);		//???
			else if(g_ucSrcModeIndex==36)	//1080i  @60Hz
				msSetBK0_0D(7);
			else if(g_ucSrcModeIndex==37)	//1080P  @50Hz
				msSetBK0_0D(13);		//???
			else if(g_ucSrcModeIndex==38)	//1080P  @60Hz
				msSetBK0_0D(13);		//???

			#if (VGA_ENABLE==0) 	//gan add
				g_ucSrcModeIndex -=29;
			#endif

            ReadModeSetting(); // restore user's settings from NVRAM for each mode
            if (msSetupMode()==FALSE) // setup scaler
            {
                Set_InputTimingChangeFlag(); // setup mode failed
                msSetBlueScreen( _ENABLE, FR_BLACK); // setup freerun mode
                printMsg("Failed to setup mode");
                return;
            }
			Set_ShowSourceFlag();	//gan add
        }
        else
        {
            printMsg("unsupported mode");
        }
    }

    msSetScaler();
    
    if (SyncLossState() || UnsupportedModeFlag)
    {
        msSetBlueScreen( _ENABLE, FR_BLUE); // setup freerun mode
        Power_TurnOffGreenLed(); // turn off green led
    }
    else
    {
        Power_TurnOnGreenLed(); // turn on green led
    }


    msSetInterrupt(INTERRUPT_PC);

    Power_TurnOnPanel(); // turn on panel
    Menu_InitAction(); // initial menu osd state
}

void msPrepareForTimingChange(void)
{

    msSetInterrupt(INTERRUPT_DISABLE);
    Clr_ForcePowerSavingFlag();
    g_ucPowerDownCounter=0;

    if (PowerSavingFlag)
        Power_PowerOnSystem();
    else
        Power_TurnOffPanel();

    msSetBlueScreen( _ENABLE, FR_BLUE);

    Osd_Hide();

    if (InputTimingStableFlag)
    {
    	msWriteByte(BK0_E2_SWRST0, OP2R_B|ADCR_B);// Reset Graphic port to re-counter input hfreq & vtotal
      	Delay1ms(3);
      	msWriteByte(BK0_E2_SWRST0, 0);
      	Delay1ms(20);
    }

  Clr_InputTimingStableFlag();	 // reset input timing stable and wait for timing stable
  g_ucInputTimingStableCounter=0;
  SrcFlags&=~(bUnsupportMode|bUserMode);

}
//==========================================================

BOOL msSyncLossStateDetect(void)
{
    BYTE fStatus;
    BOOL result=TRUE;

    fStatus=msGetInputStatus();
    
    if (fStatus&SyncLoss)
      result=FALSE;
    else
      SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
    return result;
}

BOOL msValidTimingDetect(void)
{
    BYTE fStatus;

    fStatus=msGetInputStatus();

    if (fStatus&SyncLoss) // no sync
    {
        SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
        return TRUE;
    }
    else
    {
        if (SyncPolarity(SrcFlags)!=SyncPolarity(fStatus)) // Sync polarity changed
        {
            SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
            return TRUE;
        }
        else
        {
      	    WORD tempPeriod;

            SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
            tempPeriod=msReadWord(BK0_EB_HSPRD_H)&0x1FFF;
            //printf("HPeriod %d", tempPeriod);
            if (g_ucInputTimingStableCounter==0)
                SrcHPeriod=tempPeriod;
            if (abs(tempPeriod-SrcHPeriod)>HPeriod_Torlance) // HPeriod changed
            {
                //printf("\r\nHPeriod %d", tempPeriod);
                return TRUE;
            }

            tempPeriod=msReadWord(BK0_ED_VTOTAL_H)&0x7FF;
            //printf("VTotal %d", tempPeriod);
            if (g_ucInputTimingStableCounter==0)
                SrcVTotal=tempPeriod;
            if (abs(tempPeriod-SrcVTotal)>VTotal_Torlance) // vtotal changed
            {
                //printf("\r\nVTotal %d", tempPeriod);
                return TRUE;
            }
      	}
    }
    return FALSE;
}

BOOL msFindMode(void)
{
    WORD hFreq, vFreq;
    BYTE ucFlagBff ;

    printMsg("----msFindMode----");
    #define fStatus	 hFreq
    fStatus=msGetInputStatus();
    if (SyncPolarity(SrcFlags)!=SyncPolarity(fStatus)) // Sync polarity changed
        return FALSE;
    SrcFlags&=0x0F;
    #undef fStaus