power.c

GM5621原代码

	#ifdef PORT_IR_USED
		IRInit(gmc_T_CLK_KHZ * 1000UL);
	#endif
	}

	// reset Power On flag to indicate power off state
	PowerUpFlag.PowerOnState = gmd_FALSE;

// YuriG PDR 8946 08-06-2004
// turn off LEN only if soft power off mode
	if ((UserPrefSwitches & PowerOn) == 0)
   {
   	LedOff();	// Turn off LED
   }


	// Run keypad scanning from ISR
	// if when powering down, OCM is running at under TCLK, don't use the ISR
	// it takes too much processor time.
#if ((OCM_CLK_PWRDOWN_KHZ < T_CLK_KHZ) && (GET_KEY_TIMER_ISR == TIMER2_VECTOR))
	StopGetKeyISR();
#else
	StartGetKeyISR();
#endif
}


// Power Management Handler implementation code
//******************************************************************
// DESCRIPTION 	:	Power handler from the sync signals
//					It checks the input sync signals every 20 mSec,
//					then passes the sync state to the OSD handler.
//					The OSD handler will display the "NO SYNC" osd message
//					on the screen few seconds if it is no sync,
//					then calls the proper gsel functions to turn off/on power.
//					In this way, the OSD handler keeps track of the power
//					states from the sync signals and the power key.
// SYNTEX		:	void PowerMgmt_Handler(void)
// PARAMETERS	:
// RETURN		:
//******************************************************************
void PowerMgmt_Handler(void)
{
   BYTE SyncState;

	if (gm_TimerCheck(PowerHandler_10ms_TMR)  == gmd_TMR_ACTIVE)
		return;

	Msg = GetMsg( &PowerHandlerQ );
#if DEBUG_PH && DEBUG_MSG
	if( Msg != QUEUE_EMPTY ) msg( "Message %d", Msg);
#endif

   SyncState = B_SyncState;   // Copy the global sync state variable.

   if( (Msg == MTP_SOFTKEY_OFF) && (PowerHandlerState != PWR_KEY_OFF_STATE) )
   {
#ifdef PHOENIX_U
   	gm_SetRegBitsByte(DISPLAY_CONTROL1, FORCE_BKGND);	// Test 1112
   	gm_SyncUpdate();
#endif
      #if Enable_AOC		// Louis 0822
         // DisableAOCMain();
         EnableDontUpdateAOCMain();
      #endif

       msg("Power Saving - Soft key off", 0);
		 PowerUpFlag.ReqPowerOff_Key = gmd_TRUE;
	    PowerHandlerState = PWR_KEY_OFF_STATE;
		 SystemFlags.SystemNormal = gmd_FALSE;
		 SystemFlags.PowerSaving = gmd_TRUE;
		 SystemFlags.ModeHandlerOff = gmd_TRUE;
	#if USE_AUDIO && USE_GSEL_DRVR_MODEL    // Mute audio when Power Key off 
		gm_CallDriver(DEV_AUDIO_DECODER, gmd_AUD_SET_OUTPUT_MUTE, AUDIO_MUTE_ON, NULL_PTR);
	#endif
		 
   }

   switch (PowerHandlerState)
   {
	   case PWR_KEY_OFF_STATE:
		   if(Msg == MTP_SOFTKEY_ON)
         {
            msg("Power On - Soft key On", 0);
			   PowerUpFlag.ReqPowerOn_Key = gmd_TRUE;
			   PowerHandlerState = PWR_ON_STATE;
            SystemFlags.SystemNormal = gmd_TRUE;
            SystemFlags.PowerSaving = gmd_FALSE;
            SystemFlags.ModeHandlerOff = gmd_FALSE;
            FirstPowerUp = 0;
         }

			else if (Msg != MTP_SOFTKEY_OFF)
			{
#if USE_POWERDOWN_ROM_CE
				ExecuteFromRAM( 0 );
#endif /* USE_POWERDOWN_ROM_CE */
			}

		   break;
	   case PWR_ON_STATE:
			if((SystemFlags.SyncDetect == gmd_FALSE) &&
				(SystemFlags.TestPatternRunning == gmd_FALSE))
			{
				if(InputCableDetect() == gmd_TRUE)
					msg("Syncs Lost", 0);
				PowerHandlerState = DetNewPwrState(SyncState);
			}
			break;
      case PWR_STANDBY_STATE:
	   case PWR_SUSPEND_STATE:
		   if ( SystemFlags.SyncDetect == gmd_TRUE )
			{
            msg("Power On - Syncs Found", 0);
            PowerHandlerState = PWR_ON_STATE;
         }
		   else
         {
            PowerHandlerState = DetNewPwrState(SyncState);
			}
		   break;
		case PWR_DOWN_WAIT_STATE:
			if(UserPrefMHAutoScanMode == gmd_FALSE)
			{// if UserPrefMHAutoScanMode is disabled, and the port changes, then
			 // someone has manually changed the port, reset the PowerDownWait
			 // timer to give more time to find syncs.
				static BYTE oldPort = 0xff;
				if(oldPort != B_SyncStatePort)
				{
					msg("Port Changed, Reset timer",0);
					gm_TimerStart(PowerDownWait_10ms_TMR, POWER_DOWN_WAIT_TIMEOUT);
					oldPort = B_SyncStatePort;
				}
			}
			if((SystemFlags.SyncDetect == gmd_TRUE ) ||
				(SystemFlags.TestPatternRunning == gmd_TRUE))
			{
				msg("Power On - Syncs Found", 0);
            PowerHandlerState = PWR_ON_STATE;
         }
		   else if( ( Msg == MTP_POWER_DOWN ) ||
						( gm_TimerCheck(PowerDownWait_10ms_TMR) == gmd_TMR_TIMED_OUT ) )
         {
            msg( "Osd Acknowledged or Wait Timed Out", 0);
			   gm_TimerStop(PowerDownWait_10ms_TMR);
			   PowerUpFlag.ReqPowerOff_Sync = gmd_TRUE;
			   PowerHandlerState = PWR_DOWN_STATE;
            SendMsg( &OsdQ, MTO_POWER_DOWN );
            SystemFlags.PowerSaving = gmd_TRUE;
            OsdNoticed = gmd_FALSE;
         }
         else
         {
            if( (gm_TimerRead(PowerDownWait_10ms_TMR) < PWRDWN_OSDACK_TIMEOUT) &&
                (!OsdNoticed) )
            {
               msg("Send Power Down Notice to OSD", 0);
               SendMsg( &OsdQ, MTO_POWER_DOWN_NOTICE );
               OsdNoticed = gmd_TRUE;
            }
			   PowerHandlerState = DetNewPwrState(SyncState);
         }
         break;
	   case PWR_DOWN_STATE:
		   if (SystemFlags.SyncDetect == gmd_TRUE)
			{				   
			#ifdef PHOENIX_U
				// Test 1110
				gm_WriteRegByte(DISPLAY_CONTROL1, 1);
				gm_ForceUpdate();
            #endif
            msg("Power On - Syncs Found", 0);
			   PowerUpFlag.ReqPowerOn_Sync = gmd_TRUE;
            //SendMsg( &OsdQ, MTO_POWER_ON );
            PowerHandlerState = PWR_ON_STATE;
            SystemFlags.PowerSaving = gmd_FALSE;
#if defined(PHOENIX_U) && ((defined(EV_BD_B_57XX) && ( BOARD == EV_BD_B_57XX )) || (defined(RD3_57XX) && ( BOARD == RD3_57XX )))
//Video and Component port will not scan during power saving mode. As a result, 
//System can be forced wake_up by receving a MTP_SOFTKEY_ON event (User press KeyPad "Right" key.)
//(P.S OSD project need to modify to generate MTP_SOFTKEY_ON event)
         	}     
		   	else if (Msg == MTP_SOFTKEY_ON)
		   	{
            msg("Force Power On For Port Searching", 0);
		    PowerUpFlag.ReqPowerOn_Key = gmd_TRUE;
			PowerHandlerState = PWR_ON_STATE;
            SystemFlags.SystemNormal = gmd_TRUE;
            SystemFlags.PowerSaving = gmd_FALSE;
            SystemFlags.ModeHandlerOff = gmd_FALSE;
            FirstPowerUp = 0;
			SendMsg( &OsdQ, MTO_MODE_CHANGE);
			#if (BOARD == RD3_57XX )			
			ChangeToPort(3);  //To scan video port first
			#elif (BOARD == EV_BD_B_57XX )			
			ChangeToPort(2);  //To scan video port first
			#endif
			
#endif
		   	}
         break;
      default:
         break;
   }


   if( PowerUpFlag.ReqPowerOn_Key == gmd_TRUE )
   {
	   PowerUp();
	   PowerUpFlag.ReqPowerOn_Key = gmd_FALSE;
	   PowerUpFlag.SoftPowerOnState = gmd_TRUE;
		InitModeHandler();                        // Initialize Mode Handler.
		SoftPowerReInitforTestPattern=1;

#if (USE_ACC_ACM || USE_ACM_3D)
      if (UserPrefThemeMode != ACM_MODE_NORMAL)
         AdjustHightlightWindow();
#endif
#ifdef PHOENIX_U		
	if (!SystemFlags.TestPatternRunning)     //When testpattern running, don't enable output to avoid garbage flashing.
//		  gm_WriteRegByte(OP_ENABLE, 0x1f);          //to enable No signal/ No cable OSD when poweron  //sweng0307
		  gm_PowerUpPanel();          
#endif

   }
   else if ( PowerUpFlag.ReqPowerOn_Sync == gmd_TRUE )
   {
	   PowerUp();
	   PowerUpFlag.ReqPowerOn_Sync = gmd_FALSE;
	   PowerUpFlag.SyncPowerOnState = gmd_TRUE;

#if USE_VPORT && USE_GSEL_DRVR_MODEL
		gm_CallDriver(DEV_VIDEO_DECODER, gmd_VID_SET_MODE, VDD_MODE_INIT, NULL_PTR);
#endif		

   }
   else if( PowerUpFlag.ReqPowerOff_Key == gmd_TRUE )
   {
      msg("Power Off Key Req", 0);
	   PowerDown();
	   PowerUpFlag.ReqPowerOff_Key = gmd_FALSE;
	   PowerUpFlag.SoftPowerOnState = gmd_FALSE;

#if USE_POWERDOWN_ROM_CE
		// At this point, we execute from RAM. The ROM power
		// is cycled with the ON and OFF time controlled in
		// RAM code.
	   msg("Executing from RAM - Soft power off",0); 
		InitXROMStateMachineSettleCount();
	   ExecuteFromRAM( 0 );
#endif // USE_POWERDOWN_ROM_CE
   }
	else if( PowerUpFlag.ReqPowerOff_Sync == gmd_TRUE )
   {
      msg("Power Off Sync Req", 0);
	   PowerDown();
	   PowerUpFlag.ReqPowerOff_Sync = gmd_FALSE;
		PowerUpFlag.SyncPowerOnState = gmd_FALSE;

		if(UserPrefMHAutoScanMode == gmd_FALSE)
		{// if autoscan disabled, we have to make sure we leave power on
		 // to the port we're monitoring.
			PowerUpDevice(InputPortArray[gmvb_CurrentPortMain].PowerDev);
		}
	}
	gm_TimerStart(PowerHandler_10ms_TMR, 0x02); // start 20ms timer.
}

// Power Management Handler implementation code
//******************************************************************
// DESCRIPTION 	:	Power handler from the sync signals
//					It checks the input sync signals every 20 mSec,
//					then passes the sync state to the OSD handler.
//					The OSD handler will display the "NO SYNC" osd message
//					on the screen few seconds if it is no sync,
//					then calls the proper gsel functions to turn off/on power.
//					In this way, the OSD handler keeps track of the power
//					states from the sync signals and the power key.
// SYNTEX		:	void PowerMgmt_Handler(void)
// PARAMETERS	:
// RETURN		:
//******************************************************************
static PwrHandlerStates __near DetNewPwrState( BYTE SyncState )
{
   switch (SyncState)
   {
		case gmd_HOFFVON:
			#if ALT_PWR_HANDLER_MTO_MESSAGE
				if( PowerHandlerState != PWR_STANDBY_STATE )
				{
					msg("No H Sync - Power StandBy ", 0);
					SendMsg( &OsdQ, MTO_POWER_STANDBY );
					ExtPowerStandBy();
					return PWR_STANDBY_STATE;
				}
			#else
				if(InputCableDetect() == gmd_TRUE)		// 1124
				{
				if( PowerHandlerState != PWR_DOWN_WAIT_STATE )
				{
					msg("No H Sync - Power Down Wait ", 0);
					gm_TimerStart(PowerDownWait_10ms_TMR, POWER_DOWN_WAIT_TIMEOUT);
					return PWR_DOWN_WAIT_STATE;
				}
				}
				else
					gm_TimerStop(PowerDownWait_10ms_TMR);
					
			#endif
			break;
		case gmd_HONVOFF:
			#if ALT_PWR_HANDLER_MTO_MESSAGE
				if( PowerHandlerState != PWR_SUSPEND_STATE )
				{
					msg("No V Sync - Power Suspend ", 0);
					SendMsg( &OsdQ, MTO_POWER_SUSPEND );
					ExtPowerSuspend();
					return PWR_SUSPEND_STATE;
				}
			#else
				if(InputCableDetect() == gmd_TRUE)		// 1124
				{
				if( PowerHandlerState != PWR_DOWN_WAIT_STATE )
				{
					msg("No V Sync - Power Down Wait ", 0);
					gm_TimerStart(PowerDownWait_10ms_TMR, POWER_DOWN_WAIT_TIMEOUT);
					return PWR_DOWN_WAIT_STATE;
				}
				}
				else
					gm_TimerStop(PowerDownWait_10ms_TMR);
			#endif
			break;
		case gmd_HOFFVOFF:
			if(InputCableDetect() == gmd_TRUE)
			{
				if( PowerHandlerState != PWR_DOWN_WAIT_STATE )
				{
					msg("No H Sync and V Sync - Power Down Wait ", 0);
					gm_TimerStart(PowerDownWait_10ms_TMR, POWER_DOWN_WAIT_TIMEOUT);
					return PWR_DOWN_WAIT_STATE;
				}
			}
			else
				gm_TimerStop(PowerDownWait_10ms_TMR);
			break;
		default:

         break;
   }
   return PowerHandlerState; // No change in State
}

//******************************************************************************
// FUNCTION     :   void ExtPowerUp (void)
//
// USAGE        :
//
// INPUT        :
// OUTPUT       :
// GLOBALS      :
// USED_REGS    :
//******************************************************************************
void ExtPowerUp (void)
{
#if USE_VPORT && defined(VPORT_CTRL)
	gm_WriteRegByte(VPORT_CTRL, VPORT_EN);
#endif //USE_VPORT
}

//******************************************************************************
// FUNCTION     :   void ExtPowerDown (void)
//
// USAGE        :
//
// INPUT        :
// OUTPUT       :
// GLOBALS      :
// USED_REGS    :
//******************************************************************************
void ExtPowerDown (void)
{
#if USE_VPORT && defined(VPORT_CTRL)
	gm_WriteRegByte(VPORT_CTRL, (gm_ReadRegByte(VPORT_CTRL) & ~VPORT_EN));
#endif //USE_VPORT	
}

//******************************************************************************
// FUNCTION     :   void ExtPowerStandBy (void)
//
// USAGE        :
//
// INPUT        :
// OUTPUT       :
// GLOBALS      :
// USED_REGS    :
//******************************************************************************
void ExtPowerStandBy( void )
{
}

//******************************************************************************
// FUNCTION     :   void ExtPowerSuspend (void)
//
// USAGE        :
//
// INPUT        :
// OUTPUT       :
// GLOBALS      :
// USED_REGS    :
//******************************************************************************
void ExtPowerSuspend( void )
{
}