drvpower.c

mstar 776 开发的车载dvd

////////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006-2007 MStar Semiconductor, Inc.
// All rights reserved.
//
// Unless otherwise stipulated in writing, any and all information contained
// herein regardless in any format shall remain the sole proprietary of
// MStar Semiconductor Inc. and be kept in strict confidence
// (¨MStar Confidential Information〃) by the recipient.
// Any unauthorized act including without limitation unauthorized disclosure,
// copying, use, reproduction, sale, distribution, modification, disassembling,
// reverse engineering and compiling of the contents of MStar Confidential
// Information is unlawful and strictly prohibited. MStar hereby reserves the
// rights to any and all damages, losses, costs and expenses resulting therefrom.
//
// Description:
//
////////////////////////////////////////////////////////////////////////////////

//------------------------------------------------------------------------------
// Include Files
//------------------------------------------------------------------------------

#include <stdio.h>
#include <intrins.h>

#include "board.h"
#include "datatype.h"
#include "hwreg.h"
#include "sysinfo.h"
#include "sramvar.h"
#include "drvuart.h"
#include "drvtimer.h"
#include "drvsys.h"
#include "mreg51.h"
#include "analog_reg.h"
#include "drvpower.h"
#include "msGPIO.h"
#include "drviic.h"
#include "msIR.h"
#include "drvAuCommon.h"
#include "drvGlobal.h"
#include "msKeyPad.h"
#include "drvscaler.h"
#include "drvGPIO.h"


//-------------------------------------------------------------------------------------------------
// Global Variables
//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
// Local Defines
//-------------------------------------------------------------------------------------------------
#define DRVPOWER_DBG(x) //x

U8 data u8PDFunc;

BOOLEAN gRTCWakeup;

//-------------------------------------------------------------------------------------------------
// Local Function
//-------------------------------------------------------------------------------------------------
#define POWER_TEST_INTERNAL     0
#if POWER_TEST_INTERNAL
static U8 _u8Cnt;
#define DOWN_UP_P1_1(n)                 \
{                                       \
    for(_u8Cnt=0;_u8Cnt<n;_u8Cnt++)     \
    {                                   \
        P1 &= ~0x02;                    \
        P1 |= 0x02;                     \
    }                                   \
}
#endif



//-------------------------------------------------------------------------------------------------
/// Setting power mode: PM_MODE_ON, PM_MODE_OFF_EXEC, PM_MODE_OFF, PM_MODE_ON_EXEC
/// @param
/// @return
///
//-------------------------------------------------------------------------------------------------
void MDrv_Power_SetMode(U8 u8Mode)
{
    XBYTE[PM_OFF_FLAG] = (XBYTE[PM_OFF_FLAG] & ~PM_MODE_MASK) | u8Mode;
}


//-------------------------------------------------------------------------------------------------
/// Checking if the system is 1st boot up
/// @param
/// @return
///
//-------------------------------------------------------------------------------------------------
/*BOOLEAN MDrv_Power_Is1STBootUp()
{
    if(!(XBYTE[PM_OFF_FLAG] & PM_FIRST_BOOTUP))
    {
        XBYTE[PM_OFF_FLAG] |= PM_FIRST_BOOTUP;
        return TRUE;
    }
    else
        return FALSE;
}


//-------------------------------------------------------------------------------------------------
/// Checking if it is power down mode: PM_MODE_OFF_EXEC
/// @param
/// @return
///
//-------------------------------------------------------------------------------------------------
BOOLEAN MDrv_Power_IsPowerDown()
{
    u8PDFunc = 0;

    if(!(XBYTE[PM_OFF_FLAG] & PM_FIRST_BOOTUP))
    {
        gWakeupSystemTime = 0xFFFFFFFF;
        XBYTE[PM_OFF_FLAG] |= PM_FIRST_BOOTUP;
    }

    if((XBYTE[PM_OFF_FLAG] & PM_MODE_MASK) == PM_MODE_OFF_EXEC)
    {

        switch(XBYTE[PM_OFF_FLAG] & PM_PDMODE_MASK)
        {
            case PM_PDMODE_S1:
                u8PDFunc = PDF_EXT_DEVICE + PDF_ANA;
                break;
            case PM_PDMODE_S2:
                u8PDFunc = PDF_EXT_DEVICE + PDF_ANA;
                break;
            case PM_PDMODE_S3:
                u8PDFunc = PDF_EXT_DEVICE + PDF_ANA + PDF_DIG + PDF_SDR + PDF_MPLL + PDF_ACLK;
                break;
            case PM_PDMODE_S4:
                u8PDFunc = PDF_EXT_DEVICE + PDF_ANA + PDF_DIG + PDF_SDR + PDF_MPLL + PDF_ACLK + PDF_HWAKEUP;
                break;
            default:
                break;
        }

        return TRUE;
    }
    else if ((XBYTE[PM_OFF_FLAG] & PM_MODE_MASK) == PM_MODE_OFF)
    {
	return TRUE;
    }
    else
    {
        return FALSE;
    }
}*/


//-------------------------------------------------------------------------------------------------
/// Setting power down mode: S1, S2, S3, S4
/// @param
/// @return
///
//-------------------------------------------------------------------------------------------------
void MDrv_Power_Set_PDMode(U8 u8Mode)
{
    DRVPOWER_DBG(printf("\r\n !!! MDrv PDMode=%bu", u8Mode));

    #if ( MS_BOARD_TYPE_SEL == BD_MST7702_DEMO_B02A)
    //GPIOWrite(1, 0);// Dyson asked 071101_3
    PANEL_POWER_OFF;
    #endif

    XBYTE[PM_OFF_FLAG] &= ~PM_PDMODE_MASK;
    switch(u8Mode)
    {
        case POWERMODE_S1:
            XBYTE[PM_OFF_FLAG] |= PM_PDMODE_S1;
            u8PDFunc = PDF_EXT_DEVICE + PDF_ANA;
            break;
        case POWERMODE_S2:
            XBYTE[PM_OFF_FLAG] |= PM_PDMODE_S2;
            u8PDFunc = PDF_EXT_DEVICE + PDF_ANA;
            break;
        case POWERMODE_S3:
            XBYTE[PM_OFF_FLAG] |= PM_PDMODE_S3;
            u8PDFunc = PDF_EXT_DEVICE + PDF_ANA + PDF_DIG + PDF_SDR + PDF_MPLL + PDF_ACLK;
            break;
        case POWERMODE_S4:
            XBYTE[PM_OFF_FLAG] |= PM_PDMODE_S4;
            u8PDFunc = PDF_EXT_DEVICE + PDF_ANA + PDF_DIG + PDF_SDR + PDF_MPLL + PDF_ACLK + PDF_HWAKEUP;
            break;
        case POWERMODE_S5:// kevin 20070912
            MDrv_WriteRegBit(BK_34_50_H, 0, _BIT1);// kevin 071107
            MDrv_Timer_Delayms(1);
            MDrv_WriteRegBit(BK_34_50_H, 1, _BIT1);// kevin 071107

            #if ((WAKEUP_MODE_SEL & WAKEUP_BY_POWERKEY) || (WAKEUP_MODE_SEL & WAKEUP_BY_TOUCHPAD))  // keivn 071107
            MDrv_Write2Byte(BK_SAR_13_L, 0x0061);
            MDrv_Write2Byte(BK_SAR_00_L, 0x02A0);
            MDrv_Write2Byte(BK_SAR_01_L, 0x0002);
            MDrv_Write2Byte(BK_SAR_10_L, 0x80FF);
            #endif

            MDrv_Write2Byte(BK_34_54_L, 0x000A);
            MDrv_Write2Byte(BK_34_55_L, 0x000A);
            MDrv_Write2Byte(BK_34_50_L, 0x0392);// THD for Powerkey, Wakeup, Touchpad
            //MDrv_Write2Byte(BK_34_51_L, 0x005C);

            MDrv_Write2Byte(BK_34_51_L, 0x0000);

            #if (WAKEUP_MODE_SEL & WAKEUP_BY_POWERKEY)  // keivn 071107
            MDrv_WriteByte(BK_34_51_L, MDrv_ReadByte(BK_34_51_L) | (_BIT2+_BIT3));
            #endif

            #if 0// these 2 bits must set "0" (WAKEUP_MODE_SEL & WAKEUP_BY_WAKEUPKEY)  // keivn 071107
            MDrv_WriteByte(BK_34_51_L, MDrv_ReadByte(BK_34_51_L) | (_BIT4+_BIT5));
            #endif

            #if (WAKEUP_MODE_SEL & WAKEUP_BY_TOUCHPAD)  // keivn 071107
            MDrv_WriteByte(BK_34_51_L, MDrv_ReadByte(BK_34_51_L) | (_BIT0+_BIT1));
            #endif

            #if (WAKEUP_MODE_SEL & WAKEUP_BY_IR)  // keivn 071107
            MDrv_Write2Byte(BK_34_52_L, 0x02B4);
            #else
            MDrv_Write2Byte(BK_34_52_L, 0x0200);
            #endif

            MDrv_Write2Byte(BK_34_53_L, 0x2032);

            MDrv_WriteRegBit(BK_34_52_L, 1, _BIT1);// kevi 071107

            MDrv_Write2Byte(BK_34_50_L, 0x0292);
            //MDrv_WriteRegBit(BK_34_50_H, 0, _BIT1);// kevin 071106
            //MDrv_WriteRegBit(BK_34_50_H, 1, _BIT1);// kevin 071106
            break;
        default:
            break;
    }
}


//-------------------------------------------------------------------------------------------------
/// Getting power down mode: S1, S2, S3, S4
/// @param
/// @return
///
//-------------------------------------------------------------------------------------------------
U8 MDrv_Power_Get_PDMode()
{
    U8 u8Ret;
    switch(XBYTE[PM_OFF_FLAG] & PM_PDMODE_MASK)
    {
        case PM_PDMODE_S1:
            u8Ret = POWERMODE_S1;
            break;
        case PM_PDMODE_S2:
            u8Ret = POWERMODE_S2;
            break;
        case PM_PDMODE_S3:
            u8Ret = POWERMODE_S3;
            break;
        case PM_PDMODE_S4:
            u8Ret = POWERMODE_S4;
            break;
        default:
            u8Ret = POWERMODE_S0;
            break;
    }
    return u8Ret;
}


//-------------------------------------------------------------------------------------------------
/// Power wakeup : IR Wakeup
/// @param
/// @return
/// Return true under conditions: FIFO not empty, power on key, repeat flag = 0, power management mode is OFF
//-------------------------------------------------------------------------------------------------
#define IRDA_DATA_CHECK     1
#define IRDA_REPEAT_CHECK   1
BOOLEAN MDrv_Power_CheckPowerOnKey(void)
{
    // IR FIFO Data Empty Flag
    #if IRDA_DATA_CHECK
    if ((XBYTE[IR_RPT_FIFOEMPTY] & 0x2))
    {
        return FALSE;
    }
    #endif

    //if (XBYTE[IR_KEY] == IRDA_KEY_MAPPING_POWER)
    if (XBYTE[IR_KEY] == IRDA_KEY_MAPPING_POWER ||
        XBYTE[IR_KEY] == IRKEY_CHANNEL_PULS ||
        XBYTE[IR_KEY] == IRKEY_CHANNEL_MINUS ||
        XBYTE[IR_KEY] == IRKEY_NUM_0 ||
        XBYTE[IR_KEY] == IRKEY_NUM_1 ||
        XBYTE[IR_KEY] == IRKEY_NUM_2 ||
        XBYTE[IR_KEY] == IRKEY_NUM_3 ||
        XBYTE[IR_KEY] == IRKEY_NUM_4 ||
        XBYTE[IR_KEY] == IRKEY_NUM_5 ||
        XBYTE[IR_KEY] == IRKEY_NUM_6 ||
        XBYTE[IR_KEY] == IRKEY_NUM_7 ||
        XBYTE[IR_KEY] == IRKEY_NUM_8 ||
        XBYTE[IR_KEY] == IRKEY_NUM_9 ||
        XBYTE[IR_KEY] == IRKEY_NUM_0 ||
        XBYTE[IR_KEY] == IRKEY_INPUT_SOURCE ||
        XBYTE[IR_KEY] == IRKEY_TV_INPUT
        )
    {

    	XBYTE[IR_FIFO_READ_PULSE]=0x01;
        #if IRDA_REPEAT_CHECK
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();
        _nop_ ();

        if ((XBYTE[IR_RPT_FIFOEMPTY] & 0x1))
            return FALSE;
        #endif

        if ((XBYTE[PM_OFF_FLAG] & PM_MODE_MASK) == PM_MODE_OFF)
        {
            return TRUE;
        }
    }
    else
    	XBYTE[IR_FIFO_READ_PULSE]=0x01;