drvscaler_bloader.c

mstar 776 开发的车载dvd

    /* 2nd delay time */
    if (bPanelOn)
        delayTime = pnlGetOnTiming2();
    else
        delayTime = pnlGetOffTiming2();

    //lachesis_070304
#if 0
    MDrv_Timer_Delayms(delayTime);

    /* enable/disable panel back-light */
    MDrv_Scaler_SetPanelBacklight(bPanelOn);
#else
    g_u32LVDSDataEnableTime = MDrv_Timer_GetTime0();
    g_bIsPanelOnTimingCheckValid = TRUE;
#endif
}

//-----------------------------------------------------------------------------
// power
//-----------------------------------------------------------------------------

void MDrv_Scaler_PowerOn(void)
{
    // ToDo
    //{BK0_F0, 0x00}, // power down chip except mode detection

    /* power down output PLL */
    MDrv_WriteRegBit(BK_LPLL_03_L, DISABLE, _BIT5);

    /* sw reset */
    MDrv_Scaler_SoftwareResetEx(RST_IP_ALL|RST_ADC|RST_DVI);

    /* cc.chen - T.B.D. - ToDo HDMI */
    //msVdMcuReset();
    //msWriteByte(BK0_00, REG_BANK_HDMI); // select register bank scaler
    //msWriteByte(BKB_3C, 0x00); // HDMI audio PLL

    if( IsUseAnalogPort(stSystemInfo.enInputPortType) || IsUseHdmiPort(stSystemInfo.enInputPortType))
    {
        g_bInputTimingChange = TRUE;
        g_u8CurrentSyncStatus &= ~MD_SYNC_LOSS;
    }
}

void MDrv_Scaler_PowerOff(void)
{
//lachesis_070310 this is duplicated code.
//    MDrv_Scaler_SetPanelOnOff(FALSE);

    /* cc.chen - T.B.D. - ToDo HDMI */
    //msWriteByte(BK0_00, REG_BANK_HDMI); // select register bank scaler
    //msWriteByte(BKB_3C, 0x40); // HDMI&IIS Out audio PLL power down

    /* power down output PLL */
    MDrv_WriteRegBit(BK_LPLL_03_L, ENABLE, _BIT5);

    MDrv_ADC_PowerOff();

    //msWriteByte(BK0_F0, _BIT5 | _BIT4 | _BIT1 | _BIT0);// power down chip except DDC SDRAM //Bit 5 is recomand by JM.

    if(IsUseAnalogPort(stSystemInfo.enInputPortType) || IsUseHdmiPort(stSystemInfo.enInputPortType))
    {
        g_bInputTimingChange = FALSE;
    }
}

//-----------------------------------------------------------------------------
// reset
//-----------------------------------------------------------------------------

void MDrv_Scaler_SoftwareResetEx(U16 u16Param)
{
    U8 u8Bank;
    U8 u8ParamMSB, u8ParamLSB;

    u8ParamMSB = (u16Param & 0xFF00) >> 8;
    u8ParamLSB = (u16Param & 0xFF);

    if (u8ParamLSB)
    {
        u8Bank = MDrv_ReadByte(BK_SELECT_00);
        MDrv_WriteByte(BK_SELECT_00, REG_BANK_RESET);

        MDrv_WriteByte(BK_SC_SWRESET_02_L, u8ParamLSB);
        MDrv_WriteByte(BK_SC_SWRESET_02_L, 0x00);

        MDrv_WriteByte(BK_SELECT_00, u8Bank);
    }

    if (u8ParamMSB)
    {
        MDrv_WriteByte(BK_ADC_ATOP_07_L, u8ParamMSB);
        MDrv_WriteByte(BK_ADC_ATOP_07_L, 0x00);
    }
}

//-----------------------------------------------------------------------------
// screen
//-----------------------------------------------------------------------------

/******************************************************************************/
///enable/diable output black pattern
///@param bEnable \b IN
///-  False:Disable
///-  TRUE :enable
/******************************************************************************/
void MDrv_Scaler_SetBlackScreen(BOOLEAN bEnable)
{
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);
    MDrv_WriteRegBit(BK_SC_VOP_19_L, bEnable, _BIT1);
    MDrv_WriteByte(BK_SELECT_00, u8Bank);
}

//-----------------------------------------------------------------------------
// FPLL
//-----------------------------------------------------------------------------
#if (ENABLE_FPLL_CTL)
void MDrv_Scaler_CtrlFPLL(EnuFpllCtl eFlag)
{
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);

    switch((eFlag&FPLL_TUNE_TYPEMASK))
    {
        case FPLL_STOP:
            MDrv_Write2Byte(BK_SC_VOP_1E_H, 0x00);
            break;

        case FPLL_TUNE_CLK_LINE_FOR_PC_YPBPR:
            MDrv_Write2Byte(BK_SC_VOP_1E_H, 0x80);
            break;

        default:
            break;
    }

    MDrv_WriteByte(BK_SELECT_00, u8Bank);
}
#endif

//-----------------------------------------------------------------------------
// LPLL
//-----------------------------------------------------------------------------

void MDrv_Scaler_InitLPLL(void)
{
    MDrv_WriteByte( BK_ADC_ATOP_0A_L, PANEL_MPLL_LOOP_DIV2 );
    MDrv_Write2Byte(BK_LPLL_00_L, (PANEL_LPLL_INPUT_DIV_2nd<<8)  | PANEL_LPLL_INPUT_DIV_1st);
    MDrv_Write2Byte(BK_LPLL_01_L, (PANEL_LPLL_LOOP_DIV_2nd<<8)   | PANEL_LPLL_LOOP_DIV_1st);
    MDrv_Write2Byte(BK_LPLL_02_L, (PANEL_LPLL_OUTPUT_DIV_2nd<<8) | PANEL_LPLL_OUTPUT_DIV_1st);
    MDrv_Write2Byte(BK_LPLL_03_L, 0x0003);

    MDrv_WriteRegBit(BK_LPLL_03_L, PANEL_RSDS, _BIT6);
    MDrv_WriteRegBit(BK_LPLL_03_L, devPanel_Is_DUAL_PORT(), _BIT7);

    MDrv_Scaler_SetOutputDclk(600);
}

void MDrv_Scaler_SetOutputDclk(U16 u16OutputVFreq)
{
    U32 u32OutputDclk;

    ASSERT(u16OutputVFreq > 450);
    ASSERT(u16OutputVFreq < 900);

    // SET = XTAL * MM * (524288 * LM * K / OutputClk * A)
    //     = (XTAL * MM * (524288 * LM * K) / A) / OutputClk
    //     = devPanel_DClkFactor() * 10^6 / OutputClk
    //     = devPanel_DClkFactor() / (OutputClk/10^6)
    u32OutputDclk = (float)devPanel_DClkFactor() /
                    ((((float)devPanel_HTOTAL() * (float)devPanel_VTOTAL()) / 1000 * u16OutputVFreq / 1000) / 10);

    g_SrcInfo.u32Op2DclkSet = u32OutputDclk;
    MDrv_Write3Byte(BK_LPLL_0F_L, u32OutputDclk);

    MDrv_WriteByteMask(BK_LPLL_1D_H, _BIT6, _BIT6);
    MDrv_WriteByteMask(BK_LPLL_1D_H, 0x00, _BIT6);
}

//-----------------------------------------------------------------------------
// Others
//-----------------------------------------------------------------------------

/******************************************************************************/
///set free run(Disable input chanel) color
///@param u8Color \b IN
///-  0:Black
///-  1:White
///-  2:Blue
/******************************************************************************/
void MDrv_Scaler_SetFreeRunColor ( U8 u8Color )
{
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);
    MDrv_WriteByte(BK_SC_VOP_19_H, astFreeRunColor[u8Color][0]);
    MDrv_WriteByte(BK_SC_VOP_1A_L, astFreeRunColor[u8Color][1]);
    MDrv_WriteByte(BK_SC_VOP_1A_H, astFreeRunColor[u8Color][2]);
    MDrv_WriteByte(BK_SELECT_00, u8Bank);
}


/******************************************************************************/
///set free run display window size
/******************************************************************************/
void MDrv_Scaler_SetFreeRunWindow ( void )
{
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);

#if( PANEL_TYPE_SEL == PNL_DAC_CRT )
    g_u8CRT_OutVFreq = 60;
#endif

    MDrv_Write2Byte(BK_SC_VOP_08_L, devPanel_HSTART()); // Image H start
    MDrv_Write2Byte(BK_SC_VOP_09_L, devPanel_HSTART() + devPanel_WIDTH() - 1); // Image H end
    MDrv_Write2Byte(BK_SC_VOP_0A_L, PANEL_DE_VSTART + devPanel_HEIGHT() - 1); // Image V end
    MDrv_Write2Byte(BK_SC_VOP_0B_L, PANEL_DE_VSTART + devPanel_HEIGHT() - 1); // DE V end

    MDrv_WriteByte(BK_SELECT_00, u8Bank);
}

/******************************************************************************/
///set free run display window timing
/******************************************************************************/
void MDrv_Scaler_SetFreeRunTiming ( void )
{
#if (PANEL_TYPE_SEL != PNL_DAC_CRT)
    U8 u8Bank;

    u8Bank = MDrv_ReadByte(BK_SELECT_00);
    MDrv_WriteByte(BK_SELECT_00, REG_BANK_VOP);

    MDrv_Write2Byte(BK_SC_VOP_02_L, devPanel_VTOTAL() - devPanel_VSTART() );  // vsync start position
    MDrv_Write2Byte(BK_SC_VOP_03_L, devPanel_VTOTAL() - devPanel_Get_VSYNC_BACK_PORCH() );  // vsync end position

    if (devPanel_IsTCON()||(devPanel_Is_ANALOG_TCON()))
    {
        MDrv_WriteRegBit(BK_SC_VOP_02_H, ENABLE, _BIT7);
        MDrv_WriteRegBit(BK_SC_VOP_02_H, ENABLE, _BIT3); //20060808 Laurent
    }

    MDrv_Write2Byte(BK_SC_VOP_0D_L, devPanel_VTOTAL() - 1);  // output vtotal
    MDrv_Write2Byte(BK_SC_VOP_0C_L, devPanel_HTOTAL() - 1);  // output htotal

    MDrv_Scaler_SetOutputDclk(600);

    MDrv_WriteByte(BK_SC_VOP_10_H, _BIT6 ); // set output sync ctl for Freerun

    MDrv_WriteByte(BK_SELECT_00, u8Bank);
#endif
}

/******************************************************************************/
///This function will adjust backlight
///@param u8Backlight \b IN backlight value
/******************************************************************************/
//*************************************************************************
//Function name:    MDrv_ADC_AdjustBacklight
//Passing parameter:    U8 u8Backlight
//Return parameter: none
//Description:          set back light
//*************************************************************************
void MDrv_ADC_AdjustBacklight ( U8 u8Backlight )
{

//lachesis_070220
    Panel_Backlight_PWM_ADJ(u8Backlight);
    // TODO: add code
    if ( u8Backlight )
    {
    }

    // Check with H/W designer how to control Backlight, Venus using PWM to control BKL
}

/******************************************************************************/
///-This function will calculate the current scale value
//////@param wValue: the current scale value in the range 0-100
///@param wMinValue: the min scale value
///@param wMaxValue: the max scale value
///@return :the current scale value
/******************************************************************************/
U16 N100toReallyValue ( U16 wValue, U16 wMinValue, U16 wMaxValue )
{
    double dfTemp;
    wMaxValue = wMaxValue - wMinValue;
    if(!wValue)
        wValue=wMinValue;
    else
    {
        dfTemp=(double)(((wValue)*wMaxValue)/100.0+wMinValue);
        wValue=((wValue)*wMaxValue)/100+wMinValue;

        if((double)(dfTemp-wValue)>0.4)
            wValue=wValue+1;
    }
    return(U16) wValue;
}

/******************************************************************************/
///-This function will get true value of Brightness for picture mode
///@param u8value: scaled value
///@return true value of Brightness
//*************************************************************************
U8 msAPI_Mode_PictureBackLightN100toReallyValue ( U8 u8value )
{
	//lachesis 2007-01-03 11:40坷傈
    return N100toReallyValue( u8value, PANEL_MIN_PWM_DIM, PANEL_MAX_PWM_DIM );
}

void MDrv_ADC_PowerOff(void)
{
    MDrv_WriteByte(BK_ADC_ATOP_04_L, 0xFE);         // Bit-0 is relative to DRAM.
    MDrv_WriteByte(BK_ADC_ATOP_04_H, 0xFF);
    MDrv_WriteByte(BK_ADC_ATOP_05_L, 0xFF);
    MDrv_WriteByte(BK_ADC_ATOP_06_L, 0xFF);
    MDrv_WriteByte(BK_ADC_ATOP_06_H, 0xFF);
    MDrv_WriteByte(BK_ADC_ATOP_60_L, 0xEF);         // Bit-4 is relative to DRAM
    MDrv_WriteByte(BK_ADC_ATOP_60_H, 0xFF);
    MDrv_WriteByte(BK_ADC_ATOP_70_L, 0x0F);         // reg_cvbso1_pd
//    MDrv_WriteByteMask(BK_ADC_ATOP_08_L, 1, _BIT4);   // Cannot turn off MPLL
    MDrv_WriteByteMask(BK_ADC_ATOP_4C_L, 1, _BIT5);
    MDrv_WriteByteMask(BK_ADC_ATOP_40_L, 1, _BIT6);
}

#pragma SAVE
#pragma NOAREGS
void MDrv_Scaler_Isr(void)
{
}
#pragma RESTORE

/******************************************************************************/
///-This function will initialize the scaler and then set it to free run
/******************************************************************************/
void MDrv_Scaler_InitToFreeRun( void )
{
    // Scaler is reset in startup.a51 now
    // Because default value of 0xF4 is 0x00,
    // if we reset scaler here, LVDS will not be tri-sate for a while
    MDrv_Scaler_SoftwareResetEx(RST_SCALER_ALL);

    MDrv_Scaler_Init();

    devPanel_InitGammaTbl();

    // Free run
    MDrv_Scaler_SetFreeRunWindow();
    MDrv_Scaler_SetFreeRunTiming();

    MDrv_Scaler_SetFreeRunColor(0); // Black
}

#undef DRV_SCALER_C