drvscaler.c

mstar 776 开发的车载dvd

    {
        if (devPanel_IsTCON()||(devPanel_Is_ANALOG_TCON()))
        {
            MDrv_WriteByte(BK_TCON_20_H, (SET_PTC_MODE2&0xBC));	// Set L/R and U/D to low
            printf("\r\nBK_TCON_20_H=%x", MDrv_ReadByte(BK_TCON_20_H));// kevin test

            MDrv_WriteByte(BK_TCON_20_L, (SET_PTC_MODE1&0x7F));	// Disable TCON
        }

        if (devPanel_IsTTL())
            MDrv_WriteByte(BK_SC_VOP_46_L, 0xFF); //0x00);
        else
            MDrv_WriteByte(BK_SC_VOP_46_L, 0xFF);

        MDrv_MOD_PowerOff();
    }

    MDrv_WriteByte(BK_SELECT_00, u8Bank);

    /* 2nd delay time */
    if (bPanelOn)
    {
        delayTime = pnlGetOnTiming2();
        g_u32LVDSDataEnableTime = MDrv_Timer_GetTime0();
        g_bIsPanelOnTimingCheckValid = TRUE;
        MDrv_Timer_Delayms(delayTime);

#if (ENABLE_DPWM_FUNCTION)
        MDrv_Write2Byte(BK_CCFL_02_L, 0x0003);
#endif
        Panel_Backlight_VCC_ON();
    }
    else
    {
        delayTime = pnlGetOffTiming2();
        MDrv_Timer_Delayms(delayTime);
        MDrv_Scaler_SetPanelVCC(bPanelOn);
    }
}

//-----------------------------------------------------------------------------
// 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);

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

void MDrv_Scaler_PowerOff(void)
{
    /* 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))
    {
        g_bInputTimingChange = FALSE;
    }
}

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

/******************************************************************************/
///software reset for scaler
///@param u16Sel \b IN
///- software reset VDFE: BIT15
///- software reset VDCOMBF: BIT14
///- software reset EMCU: BIT13
///- software reset GMC: BIT12
///- software reset REG: BIT7
///- software reset ADC: BIT6
///- software reset DIGITAL: BIT5
///- software reset SCALER: BIT4
///- software reset DISPLAY: BIT3
///- software reset OSD: _BIT1
///- software reset ALL: BIT0
///@param u8DelayTime \b IN:
///- software reset delay time
/******************************************************************************/
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);
    }

    //printf("\r\nReseted Scaler=0x%x", u16Param);// kevin test
}

//-----------------------------------------------------------------------------
// IP MUX
//-----------------------------------------------------------------------------
void MDrv_Scaler_SetIPMux(EN_INPUT_PORT_TYPE enInputPortType, U8 u8InputSrcMux)
{
    U8 u8Clk_Mux, u8Data_Mux;
    U8 u8RGB_DataFormat = 0;
    U8 u8RGB_DataFormat1 = 0;

    if (IsUseAnalogPort(enInputPortType))
    {
		if (u8InputSrcMux == ANALOG_RGB0)
        {
        #if (ENABLE_INPUT_PIP1 || ENABLE_INPUT_PIP2)
            if (IsPip1InUse() || IsPip2InUse())// kevin 071122_0
            {
                #if (PIP_MAIN_SRC_SEL == USE_DIGITAL_RGB || PIP_MAIN_SRC_SEL == USE_MST7_DIGITAL_RGB)
                u8Clk_Mux  = SC_IPMUX_CLK_ADC_A;
                u8Data_Mux = SC_IPMUX_DATA_RGB444;
                u8RGB_DataFormat = SC_DATA_RGB888;
                #else
                u8Clk_Mux  = SC_IPMUX_CLK_ADC_A;
                u8Data_Mux = SC_IPMUX_DATA_ADC_A;
                #endif
            }
			else
            {
                u8Clk_Mux  = SC_IPMUX_CLK_ADC_A;
                u8Data_Mux = SC_IPMUX_DATA_ADC_A;
            }
		#else
            u8Clk_Mux  = SC_IPMUX_CLK_ADC_A;
            u8Data_Mux = SC_IPMUX_DATA_ADC_A;
        #endif
        }
		else if (u8InputSrcMux == ANALOG_RGB1)
		{
			u8Clk_Mux  = SC_IPMUX_CLK_ADC_B;
			u8Data_Mux = SC_IPMUX_DATA_ADC_B;
		}
        #if (ENABLE_DIGITAL_SOURCE)// kevin 071213_0
        else if (IsDigitalInUse() && (u8InputSrcMux == IP_VIDEO))
        {
        #if (INPUT_DIGITAL_TYPE == DIGITAL_CCIR656)
            u8Data_Mux = SC_IPMUX_DATA_656_B;
            u8RGB_DataFormat = SC_DATA_RGB888;
            u8RGB_DataFormat1 = SC_DATA_DOUBLE656;
            u8Clk_Mux = SC_IPMUX_CLK_656_A;
        #elif (INPUT_DIGITAL_TYPE == DIGITAL_CCIR601)
            u8Data_Mux = SC_IPMUX_DATA_601;
            u8RGB_DataFormat = SC_DATA_RGB888|_BIT4;// kevin 080129 // for cb/cr swap issue
            u8RGB_DataFormat1 = SC_DATA_BT601;
            u8Clk_Mux = SC_IPMUX_CLK_EXT_VD;
        #elif (INPUT_DIGITAL_TYPE == DIGITAL_RGB444)
            u8Clk_Mux  = SC_IPMUX_CLK_ADC_A;
            u8Data_Mux = SC_IPMUX_DATA_RGB444;
            u8RGB_DataFormat = SC_DATA_RGB888;
        #endif
        }
        #endif
		// end
    }
    else if(IsUseDigitalPort(enInputPortType))
    {
        u8Clk_Mux = SC_IPMUX_CLK_VD;
        u8Data_Mux = SC_IPMUX_CLK_VD;
    }
    else if(IsUseExtVDPort(enInputPortType))
    {
        u8Clk_Mux = u8Data_Mux = SC_IPMUX_CLK_EXT_VD;
    }

    MDrv_WriteByte(BK_IPMUX_01_L, u8Data_Mux << 4); // input select
    MDrv_WriteByte(BK_CHIPTOP_1F_H, u8Clk_Mux << 2); // idclk
    MDrv_WriteByte(BK_IPMUX_10_L, u8RGB_DataFormat << 6);  // data format

#if ENABLE_DIGITAL_SOURCE// kevin 071213_0
    if (IsDigitalInUse())
        MDrv_WriteByte(BK_IPMUX_10_H, u8RGB_DataFormat1 << 6);  // data format
#endif

    MDrv_Scaler_SoftwareResetEx(RST_IP_F2);
}

//-----------------------------------------------------------------------------
// port control
//-----------------------------------------------------------------------------
void MDrv_Scaler_SetInputPort(MS_SYS_INFO *penMsSysInfo, U8 u8InputSrcMux, U8 u8SyncSelMux)
{
    U8 u8Bank;
    U16 u16Tmp;

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

    DRVPORTMSG(printf("\r\n >>> SET Input Port=0x%bx", penMsSysInfo->enInputPortType));

    /* set ISELECT */
    if (IsUseAnalogPort(penMsSysInfo->enInputPortType))
    {
#if 0
        if (stSystemInfo.enInputSourceType == INPUT_SOURCE_YPBPR)
        {
            MDrv_ADC_Set_Vclamp(g_SrcInfo.u8SrcAdcIdx, VCLAMP_R_ClampMid | VCLAMP_B_ClampMid); // set R/B middle clamp
        }
        else
        {
            MDrv_ADC_Set_Vclamp(g_SrcInfo.u8SrcAdcIdx, VCLAMP_RGB_ClampGnd);
        }
#endif
        #if ENABLE_DIGITAL_SOURCE// kevin 071214
        if (IsDigitalInUse())
        {
            u16Tmp = MDrv_Read2Byte(BK_SC_IP1F2_02_L) & _BIT7;
            u16Tmp |= ((u8SyncSelMux & 0x2B) << 8) | ((u8InputSrcMux & 0x07));
        }
        else
        {
            u16Tmp = MDrv_Read2Byte(BK_SC_IP1F2_02_L) & _BIT7;
            u16Tmp |= (u8InputSrcMux & 0x7) | ((u8SyncSelMux & 0x7) << 4);
        }
        #else
        u16Tmp = MDrv_Read2Byte(BK_SC_IP1F2_02_L) & _BIT7;
        u16Tmp |= (u8InputSrcMux & 0x7) | ((u8SyncSelMux & 0x7) << 4);
        #endif
    }
    else
    {
        u16Tmp = MDrv_Read2Byte(BK_SC_IP1F2_02_L) & _BIT7;
        u16Tmp |= ((u8SyncSelMux& 0x23) << 8) | ((u8InputSrcMux & 0x07));
    }

    DRVPORTMSG(printf("\r\n >>> IP1F2_02=0x%x", u16Tmp));

    MDrv_Write2Byte(BK_SC_IP1F2_02_L, u16Tmp);

    /* Video port enable 10 bit input mode except external VD */
    //MDrv_WriteRegBit(BK_SC_IP1F2_03_H, ENABLE, _BIT3);  // (PQ)

    /* Disable DE */
    MDrv_WriteByteMask(BK_CHIPTOP_11_L, 0x00, 0x08);

    if(IsSrcTypeVga(penMsSysInfo->enInputSourceType))
    {
        #if ENABLE_DIGITAL_SOURCE// 071213_0
        if (IsDigitalInUse())
        {
            MDrv_WriteByte(BK_SC_IP1F2_03_L, 0x00);

            #if (INPUT_DIGITAL_TYPE == DIGITAL_CCIR601)// kevin 071218_0
            MDrv_WriteByte(BK_SC_IP1F2_08_L, (MDrv_ReadByte(BK_SC_IP1F2_08_L) | BIT1));
            #endif
        }
        #else
        MDrv_WriteByte(BK_SC_IP1F2_02_H, 0x00);
        MDrv_WriteByte(BK_SC_IP1F2_03_L, _BIT6 | _BIT3);
        #endif
        MDrv_WriteByte(BK_SC_IP1F2_24_L, 0x01); // enable ADC coast
        MDrv_WriteByte(BK_SC_IP1F2_24_H, 0x00); // enable coast window start
        MDrv_WriteByte(BK_SC_IP1F2_25_L, 0x00); // enable coast window end
        MDrv_WriteByte(BK_SC_IP1F2_25_H, 0x00); // reserved
        MDrv_WriteByte(BK_SC_IP1F2_26_L, 0x00); // disable DE glitch removal function & more tolerance for DE
        MDrv_WriteByte(BK_SC_IP1F2_26_H, 0x00); // reserved

        /* Vclamp */
// seven 070927  MDrv_WriteByte(BK_ADC_ATOP_2C_L, 0x00 | (0x1 << 2)); // G clamp to VP3
        /* clamp placement */
// seven 070927  MDrv_WriteByte(BK_ADC_DTOP_0B_L, 0x10);
        /* clamp duration */
// seven 070927  MDrv_WriteByte(BK_ADC_DTOP_0B_H, 0x08);

        /* PLL multiplier */
// seven 070830_00
        MDrv_WriteByteMask(BK_ADC_ATOP_0C_L, 0x00, _BIT2 | _BIT1 | _BIT0 );
//        MDrv_WriteByteMask(BK_ADC_ATOP_0C_L, 0x01, _BIT2 | _BIT1 | _BIT0 );
// end

        /* PLL phase setting time */
// seven 070927  MDrv_WriteByteMask(BK_ADC_DTOP_04_L, 0x05, _BIT3 | _BIT2 | _BIT1 | _BIT0 );
        /* SOG level */
// seven 070927  MDrv_WriteByteMask(BK_ADC_ATOP_1C_L, 0x25, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0 );
        /* ADC GenCtrl */
// seven 070927  MDrv_WriteByte(BK_ADC_DTOP_07_L, 0x02);
    }
    else if(IsSrcTypeYPbPr(penMsSysInfo->enInputSourceType))
    {
        MDrv_WriteByte(BK_SC_IP1F2_02_H, _BIT2);
        MDrv_WriteByte(BK_SC_IP1F2_03_L, _BIT7 | _BIT6 | _BIT5 | _BIT3);
        MDrv_WriteByte(BK_SC_IP1F2_24_L, 0x21); // enable ADC coast
        MDrv_WriteByte(BK_SC_IP1F2_24_H, 0x08); // enable coast window start
        MDrv_WriteByte(BK_SC_IP1F2_25_L, 0x08); // enable coast window end
        MDrv_WriteByte(BK_SC_IP1F2_26_L, 0x00); // disable DE glitch removal function & more tolerance for DE

        /* Vclamp */
// seven 070927 MDrv_WriteByte(BK_ADC_ATOP_2C_L, 0x22);
        /* clamp placement */
// seven 070927 MDrv_WriteByte(BK_ADC_DTOP_0B_L, 0x30);
        /* clamp duration */
// seven 070927 MDrv_WriteByte(BK_ADC_DTOP_0B_H, 0x05);
        /* PLL multiplier */
        MDrv_WriteByteMask(BK_ADC_ATOP_0C_L, 0x00, _BIT2 | _BIT1 | _BIT0 );
        /* PLL phase setting time */
// seven 070927 MDrv_WriteByteMask(BK_ADC_DTOP_04_L, 0x08, _BIT3 | _BIT2 | _BIT1 | _BIT0 );
        /* SOG level */
// seven 070927 MDrv_WriteByteMask(BK_ADC_ATOP_1C_L, 0x05, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0 );
        /* ADC GenCtrl */
// seven 070927 MDrv_WriteByte(BK_ADC_DTOP_07_L, 0x6A);
    }
    else if (IsUseDigitalPort(penMsSysInfo->enInputPortType))
    {
        MDrv_WriteByte(BK_SC_IP1F2_03_L, 0x9B);

        /* PLL multiplier */
        MDrv_WriteByte(BK_ADC_ATOP_0C_L, 0x01);
        /* PLL phase setting time */
// seven 070927 MDrv_WriteByte(BK_ADC_DTOP_04_L, 0x05);
        /* SOG level */
// seven 070927 MDrv_WriteByteMask(BK_ADC_ATOP_1C_L, 0x05, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0 );
    }
    else // external Digital VD or DTV
    {
        MDrv_WriteByte(BK_SC_IP1F2_08_L, (MDrv_ReadByte(BK_SC_IP1F2_08_L) & 0x7F));

        /* SOG level */
// seven 070927 MDrv_WriteByteMask(BK_ADC_ATOP_1C_L, 0x05, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0 );

        if (IsUseMVDPort(penMsSysInfo->enInputPortType))
        {
            // set BK1_3[4] to 0, The capature start will be 1/2 Hsync when input source is from DC0/DC1
            MDrv_WriteByte(BK_SC_IP1F2_03_L, 0x8B);
        }
        else
        {
            MDrv_WriteByte(BK_SC_IP1F2_03_L, 0x9B);
        }

        if(IsUseExtVDPort(penMsSysInfo->enInputPortType))
        {
            /* Video port disable 10 bit input mode */
            //printf("External VD, disable 10 bit\n");
            //MDrv_WriteRegBit(BK_SC_IP1F2_03_H, DISABLE, _BIT3);   // PQ
        }
    }

    MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
    MDrv_WriteByte(BK_SC_IP1F2_27_L, 0x00); // MISC function control

    MDrv_Scaler_SetFieldDetect(penMsSysInfo->enInputSourceType, &g_DisplayWindowSetting);

    MDrv_Timer_Delayms(2);

    if (IsUseAnalogPort(penMsSysInfo->enInputPortType))
    {
        MDrv_Scaler_SoftwareResetEx(RST_ADC);
    }
    else if (IsUseDigitalPort(penMsSysInfo->enInputPortType))
    {
        MDrv_VD_McuReset(20);
    }

#if 0// kevin 071221//ENABLE_POWER_SAVING_SIF
    if(IsSrcTypeATV(penMsSysInfo->enInputSourceType))
    {
        // Enable SIF
        XBYTE[0x2CC1] &= 0xE7;
        XBYTE[0x2CC0] &= 0xF3;