drvvd.c

mstar 776 开发的车载dvd

    // MDrv_WriteByte( BK_SELECT_00, u8Bank ); <- remove the bank change code
}

/******************************************************************************/
///Set COMB filter based on input port type
///@param enInputPortType \b IN: Input port type
/******************************************************************************/
void MDrv_VD_SetupComb(EN_INPUT_PORT_TYPE enInputPortType)
{
    enInputPortType = enInputPortType;

    MDrv_WriteByteMask( BK_COMB_10, 0x12, 0x17 );
}

void MDrv_VD_SetCombContrast(U8 u8Contrast)
{
    MDrv_WriteByte(BK_COMB_73, u8Contrast);
}

void MDrv_VD_SetCombBrightness(U8 u8Brightness)
{
    MDrv_WriteByte(BK_COMB_74, u8Brightness);
}






/* ====== create new VD driver APIs for moving down the code that accesses registers directly to driver ====== */
#if 0
void MDrv_VD_SetAutoHtotal (BOOLEAN bEnable)
{
    // U8 u8Bank; <- remove the bank change code

    // u8Bank = MDrv_ReadByte (BK_SELECT_00); // store bank <- remove the bank change code
    // MDrv_WriteByte (BK_SELECT_00, REG_BANK_SCALER); <- remove the bank change code

    MDrv_WriteRegBit (BK_SCALER_57, bEnable, _BIT1);

    // MDrv_WriteByte (BK_SELECT_00, u8Bank); <- remove the bank change code
}

void MDrv_VD_ColorShift (void)
{
    // U8 u8Bank; <- remove the bank change code

    // u8Bank = MDrv_ReadByte (BK_SELECT_00); // store bank <- remove the bank change code
    // MDrv_WriteByte (BK_SELECT_00, REG_BANK_SCALER); <- remove the bank change code

    MDrv_WriteRegBit (BK_SCALER_E3, ENABLE, _BIT6); // patch for color shift
    MDrv_WriteRegBit (BK_SCALER_E3, DISABLE, _BIT6);

    // MDrv_WriteByte (BK_SELECT_00, u8Bank); <- remove the bank change code
}
#endif

void MDrv_VD_SetGmcTune (U8 regVal)
{
    // U8 u8Bank; <- remove the bank change code

    // u8Bank = MDrv_ReadByte (BK_SELECT_00); // store bank <- remove the bank change code
    // MDrv_WriteByte (BK_SELECT_00, REG_BANK_ADC); <- remove the bank change code

    MDrv_WriteByteMask (BK_ADC_ATOP_37_L, regVal, 0x07); // i.e. 0x6E

    // MDrv_WriteByte (BK_SELECT_00, u8Bank); <- remove the bank change code
}

U16 MDrv_VD_GetHsyncCountAndVdStatus1stCheck (U16 *pwCurrentStatus)
{
    U16 wCurrentStatus = VD_RESET_ON;
    U8 /*u8Bank,*/ u8Dummy, u8Value;

        U16 u8VdHsyncLockedCount;


    // u8Bank = MDrv_ReadByte (BK_SELECT_00); // store bank <- remove the bank change code
    // MDrv_WriteByte (BK_SELECT_00, REG_BANK_AFEC); // Bank AFEC <- remove the bank change code

    u8Dummy = 20;
    u8VdHsyncLockedCount = 0;

    while (u8Dummy--)
    {
        MDrv_WriteByte (BK_AFEC_04, 0x00);

        if ((MDrv_ReadByte (BK_AFEC_01) & 0xF0) >= 0x60)
        {
            MDrv_WriteByte (BK_AFEC_04, 0x21);
            u8Value = MDrv_ReadByte (BK_AFEC_01);

            if (u8Value & _BIT3) // check sync found
            {
                wCurrentStatus = MDrv_VD_GetStatus ();
                u8VdHsyncLockedCount++;
                    MDrv_Timer_Delayms (50);
            }
        }
    }

    // MDrv_WriteByte (BK_SELECT_00, u8Bank); <- remove the bank change code

    *pwCurrentStatus = wCurrentStatus;
    return u8VdHsyncLockedCount;
}

U16 code SPL_NSPL[5] =
{
    1135,   // PAL
    1097,   // SECAM
    910,    // NTSC, PAL M
    917,    // PAL Nc
    1127,   // NTSC 4.43
};

U16 MDrv_VD_GetHsyncCountAndVdStatus2ndCheck (void)
{
    U16 wTemp, wLatchH;
    U8 /*u8Bank,*/ u8Dummy, u8Value;
        U16 u8VdHsyncLockedCount;


    // u8Bank = MDrv_ReadByte (BK_SELECT_00); // store bank <- remove the bank change code
    // MDrv_WriteByte (BK_SELECT_00, REG_BANK_AFEC); // Bank AFEC <- remove the bank change code

    DRVVD_DBG(printf("\r\n Second Check "));

    u8VdHsyncLockedCount = 0;
    u8Dummy = 10; // just protect program dead lock
    wLatchH = MDrv_Read2Byte_SH(BK_AFEC_C7); // SPL_NSPL, H total

    DRVVD_DBG(printf(" Ht=%d", wLatchH));

    while (u8Dummy--)
    {
        wTemp = MDrv_Read2Byte_SH(BK_AFEC_C7); // SPL_NSPL, H total
        wTemp = (wTemp+wLatchH) >> 1;
        wLatchH = wTemp;

        DRVVD_DBG(printf("\r\n Ht = %d", wLatchH));
        DRVVD_DBG(printf(" %d ", wLatchH));

        for (u8Value = 0; u8Value <= 4; u8Value++)
        {
            if (abs (wLatchH - SPL_NSPL[u8Value]) < 10)
            {
                DRVVD_DBG(putchar('+'));
                u8VdHsyncLockedCount++;
            }
            else
            {
                DRVVD_DBG(putchar('-'));
            }
        }

        DRVVD_DBG(printf("\r\n"));
    }

    // MDrv_WriteByte (BK_SELECT_00, u8Bank); <- remove the bank change code

    return u8VdHsyncLockedCount;
}

#define VD_CHK_HSYNC_WAIT                1         // ms
#define VD_CHK_HSYNC_CONT                60//40        // timeout=VD_CHK_HSYNC_CONT*VD_CHK_HSYNC_WAIT=20ms
#define VD_CHK_HSYNC_OK_THR             2   //7
#define VD_CHK_DEBOUNCE_WAIT         20        // ms
#define VD_CHK_DEBOUNCE_CONT         40        // timeout=VD_CHK_COLOR_CONT*VD_CHK_COLOR_WAIT=800ms
#define VD_CHK_NSPL_WAIT                   1       //ms
#define VD_CHK_NSPL_CONT                   500       //timeout=VD_CHK_NSPL_WAIT*VD_CHK_NSPL_CONT=400ms
#define VD_CHK_NSPL_OK_THR              10
#define VD_CHK_VideoSys_CONT                   250       //timeout=VD_CHK_NSPL_WAIT*VD_CHK_NSPL_CONT=400ms

U16 MDrv_VD_Scan_HsyncCheck(void)
{
    U8 u8VdHsyncLockedCount,u8Value;
    U16 wLatchH,u16Dummy;

    u16Dummy = VD_CHK_HSYNC_CONT;
    u8VdHsyncLockedCount = 0;

    while (u16Dummy--)
    {
        MDrv_WriteByte (BK_AFEC_04, 0x21);
        if(MDrv_ReadByte (BK_AFEC_01) & _BIT3) // check sync found
            u8VdHsyncLockedCount++;

        if(u8VdHsyncLockedCount>VD_CHK_HSYNC_OK_THR)
            break;
        MDrv_Timer_Delayms(VD_CHK_HSYNC_WAIT);
    }

    DRVVD_DBG(printf("\r\n VD_HW1st Check Hsync found=%bd, Loop=%d \r\n",u8VdHsyncLockedCount,u16Dummy));

    if(u8VdHsyncLockedCount>VD_CHK_HSYNC_OK_THR)
    {
        DRVVD_DBG(printf("Second Check \r\n"));
        u16Dummy=VD_CHK_DEBOUNCE_CONT;
        while(u16Dummy--)
        {
            MDrv_Timer_Delayms(VD_CHK_DEBOUNCE_WAIT);
            MDrv_WriteByte (BK_AFEC_04, 0x00);
            if ((MDrv_ReadByte (BK_AFEC_01) & 0xF0) >= 0x60)
            {
                DRVVD_DBG(printf("Debounce OK, count=%ld \r\n",(U32)(VD_CHK_DEBOUNCE_CONT-u16Dummy)));
                u16Dummy = VD_CHK_NSPL_CONT;
                u8VdHsyncLockedCount = 0;
                while (u16Dummy--)
                {
                    MDrv_Timer_Delayms(1);
                    wLatchH = MDrv_Read2Byte(BK_AFEC_C7); // SPL_NSPL, H total
                    DRVVD_DBG(printf("Htotal = %d\n", wLatchH));
                    for (u8Value = 0; u8Value <= 4; u8Value++)
                    {
                        if (abs (wLatchH - SPL_NSPL[u8Value]) < 10)
                        {
                            u8VdHsyncLockedCount++;
                            if(u8VdHsyncLockedCount>=VD_CHK_NSPL_OK_THR)
                            {
                                DRVVD_DBG(printf("NSPL OK, count=%ld \r\n",(U32)(VD_CHK_NSPL_CONT-u16Dummy)));
                                return VD_HSYNC_LOCKED;
                            }
                            break;
                        }
                    }
                    if((u8VdHsyncLockedCount)&&(u8Value==5))
                    {
                        DRVVD_DBG(printf("Htotal Unstable!\r\n"));
                        u8VdHsyncLockedCount--;
                    }
                }
                DRVVD_DBG(printf("VD NSPL Fail\n"));
            }
        }
        DRVVD_DBG(printf("VD MCU De Bounce Fail\n"));
    }
    return VD_RESET_ON;
}

U8 MDrv_VD_CheckTVSys(void)
{
    U8 u8Count,u8Result;

    u8Count = VD_CHK_VideoSys_CONT;
    while (u8Count--)
    {
        MDrv_WriteByte (BK_AFEC_04, 0x00);
        u8Result=MDrv_ReadByte (BK_AFEC_02) & 0x30;
        if (u8Result)  //Check 525 or 625
        {
            if (u8Result&VD_525_LINE)
            {
                DRVVD_DBG(printf("NTSC \r\n"));
                return VD_525_LINE;
            }
            else
            {
                DRVVD_DBG(printf("PAL\n"));
                return VD_625_LINE;
            }
        }
        DRVVD_DBG(printf("Checking N or P\n"));
    }
    return VD_UNKNOWN;
    DRVVD_DBG(printf("Check NTSC or PAL Timeout!\r\n"));
}
void MDrv_VD_EnableCVBSLPF(BOOLEAN bEnable)
{
    // TODO: it is proper to change the function name, (bEnable == TRUE) for TV mode, and (bEnable == FALSE) for others
    MDrv_WriteRegBit(BK_AFEC_67, bEnable, _BIT4);
    MDrv_WriteRegBit_SH(BK_AFEC_CF, bEnable, _BIT2);
}


/*
 *  H sensitivity APIs
 */
/******************************************************************************/
///Set detection window for Hsync sensitivity
///@param u8DetectWinBeforeLock \b IN: the start/end for Hsync detection window before Hsync is locked
///@param u8DetectWinAfterLock \b IN: the start/end for Hsync detection window after Hsync is locked
/******************************************************************************/
void MDrv_VD_Hsen_Set_Detect_Win (U8 u8DetectWinBeforeLock, U8 u8DetectWinAfterLock)
{
    MDrv_WriteByte (BK_AFEC_99, (u8DetectWinAfterLock & 0x0F) << 4 | (u8DetectWinBeforeLock & 0x0F));
}

/******************************************************************************/
///Set counters that are used before locked
///@param u8CntrFail \b IN: before Hsync is locked, u8CntrFail is used to count the out-of-window Hsync edges, this is the threshold to decide if Hsync is unlocked
///@param u8CntrSync \b IN: before Hsync is locked, u8CntrSync is used to count the in-window Hsync edges, this is the threshold to decide if Hsync is locked
/******************************************************************************/
void MDrv_VD_Hsen_Set_Cntr_Before_Lock (U8 u8CntrFail, U8 u8CntrSync)
{
    MDrv_WriteByteMask (BK_AFEC_9A, u8CntrFail << 4, _BIT7 | _BIT6 | _BIT5 | _BIT4);
    MDrv_WriteByteMask (BK_AFEC_9B, u8CntrSync << 0, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0);
}

/******************************************************************************/
///Set counters that are used after locked
///@param u8CntrSync \b IN: after Hsync is locked, u8CntrSync is used to monitor the in-window and out-of-window Hsync edges, this is the threshold to decide if Hsync keeps locked or lose lock
/******************************************************************************/
void MDrv_VD_Hsen_Set_Cntr_After_Lock (U8 u8CntrSync)
{
    MDrv_WriteByteMask (BK_AFEC_9C, u8CntrSync << 0, _BIT5 | _BIT4 | _BIT3 | _BIT2 | _BIT1 | _BIT0);
}

/*
 *  H/V slice level related APIs
 */
/******************************************************************************/
///Set Slice mode manaul or auto for H or V
///@param u8SliceMode \b IN: VD_SLICE_MODE_V_MANUAL for V slice manual mode and/or VD_SLICE_MODE_H_MANUAL for H slice manual mode
///- VD_SLICE_MODE_V_MANUAL | VD_SLICE_MODE_H_MANUAL: manual mode for V slice and H slice
///- VD_SLICE_MODE_V_MANUAL: manual mode for V slice
///- VD_SLICE_MODE_H_MANUAL: manual mode for H slice
///- 0: auto mode for V slice and H slice
/******************************************************************************/
void MDrv_VD_Slice_Set_Mode (U8 u8SliceMode)
{
    MDrv_WriteByteMask (BK_AFEC_66, u8SliceMode << 6, _BIT7 | _BIT6);
}

/******************************************************************************/
///Set V Slice Level
///@param u8VLevel \b IN: V Slice Level
///- VD_SLICE_LEVEL_2_8: 2/8
///- VD_SLICE_LEVEL_4_8: 4/8
///- VD_SLICE_LEVEL_5_8: 5/8
///- VD_SLICE_LEVEL_6_8: 6/8
/******************************************************************************/
void MDrv_VD_Slice_Set_V_Level (U8 u8VLevel)
{
    MDrv_WriteByteMask (BK_AFEC_73, u8VLevel << 6, _BIT7 | _BIT6);
}

/******************************************************************************/
///Set H Slice Level
///@param u8VLevel \b IN: H Slice Level
///- VD_SLICE_LEVEL_2_8: 2/8
///- VD_SLICE_LEVEL_4_8: 4/8
///- VD_SLICE_LEVEL_5_8: 5/8
///- VD_SLICE_LEVEL_6_8: 6/8
/******************************************************************************/
void MDrv_VD_Slice_Set_H_Level (U8 u8HLevel)
{
    MDrv_WriteByteMask (BK_AFEC_73, u8HLevel << 4, _BIT5 | _BIT4);
}

/*
 *  AGC related APIs
 */
/******************************************************************************/
///Set AGC mode
///@param u8AgcMode \b IN: AGC mode (auto gain or fixed gain)
///- VD_AGC_MODE_AUTO_0: auto gain
///- VD_AGC_MODE_MANUAL: fixed gain
/******************************************************************************/
void MDrv_VD_AGC_Set_Mode (U8 u8AgcMode)
{
    MDrv_WriteByteMask (BK_AFEC_43, u8AgcMode << 5, _BIT6 | _BIT5);
}

/******************************************************************************/
///Set AGC coarse gain
///@param u8AgcCoarseGain \b IN: AGC coarse gain
///- VD_AGC_COARSE_GAIN_X_0_5: x0.5
///- VD_AGC_COARSE_GAIN_X_1: x1
///- VD_AGC_COARSE_GAIN_X_2: x2
///- VD_AGC_COARSE_GAIN_X_4: x4
/******************************************************************************/
void MDrv_VD_AGC_Set_Coarse_Gain (U8 u8AgcCoarseGain)
{
    MDrv_WriteByteMask (BK_AFEC_40, u8AgcCoarseGain << 4, _BIT5 | _BIT4);
}

/******************************************************************************/
///Set AGC fine gain
///@param u16AgcFineGain \b IN: AGC fine gain, 0x500 (i.e. x2) < u16AgcFineGain < 0xE00 (i.e. x1)
/******************************************************************************/
void MDrv_VD_AGC_Set_Fine_Gain (U16 u16AgcFineGain)
{
    MDrv_WriteByteMask (BK_AFEC_3F, u16AgcFineGain << 0, _BIT3 | _BIT2 | _BIT1 | _BIT0);
    MDrv_WriteByte (BK_AFEC_44, u16AgcFineGain >> 4);
}

/*
 *  Color kill level control related APIs
 */
/******************************************************************************/
///Set Color Kill Level
///@param u8ColorKillLevel \b IN: the color kill level (9% ~ 2%)
///- VD_COLOR_KILL_LEVEL_2_PERCENT: 2%
///- VD_COLOR_KILL_LEVEL_3_PERCENT: 3%
///- VD_COLOR_KILL_LEVEL_4_PERCENT: 4%
///- VD_COLOR_KILL_LEVEL_5_PERCENT: 5%
///- VD_COLOR_KILL_LEVEL_6_PERCENT: 6%
///- VD_COLOR_KILL_LEVEL_7_PERCENT: 7%
///- VD_COLOR_KILL_LEVEL_8_PERCENT: 8%
///- VD_COLOR_KILL_LEVEL_9_PERCENT: 9%
/******************************************************************************/
void MDrv_VD_Color_Kill_Level (U8 u8ColorKillLevel)
{
    MDrv_WriteByte (BK_AFEC_D7, u8ColorKillLevel);
}

#undef DRV_VD_C