drvvd.c

mstar 776 开发的车载dvd

                 break;
            case SIG_PAL: // 1135
                 u16CurrentHStart = 1135;
                 break;
            case SIG_NTSC_443: // 1127
                 u16CurrentHStart = 1127;
                 break;
            case SIG_PAL_M: // 909
                 u16CurrentHStart = 909;
                 break;
            case SIG_PAL_NC: // 917
                 u16CurrentHStart = 917;
                 break;
            case SIG_SECAM: // 1097
                 u16CurrentHStart = 1097;
                 break;
            default:
                 /* ASSERT */
                 break;
        }
        if( u16Htotal != u16CurrentHStart )
        {
            if( u8AbnormalCounter < 15 )
                u8AbnormalCounter++;
        }
        else
        {
            if( u8AbnormalCounter > 1 )
                u8AbnormalCounter -= 2;
            else
                u8AbnormalCounter = 0;
        }
        if( u8AbnormalCounter > 10 )
        {
            u8AbnormalSignal = 1;
        }
        else if( u8AbnormalCounter == 0 )
        {
            u8AbnormalSignal = 0;
        }
        // For Bug 267 <--

        u16DataH[2] = u16DataH[1];
        u16DataH[1] = u16DataH[0];
        u16DataH[0] = u16Htotal;

        if( u16DataH[2] == u16DataH[1] && u16DataH[1] == u16DataH[0] )
        {
            if( u8HtotalDebounce > 3 )
                u16LatchH = u16DataH[0];
            else
                u8HtotalDebounce++;
        }
        else
        {
            u8HtotalDebounce = 0;
        }

        u16Htotal = u16LatchH;
        switch( u8VideoSystem )
        {
            case SIG_PAL:
            case SIG_NTSC_443:
                    u8Value = 3;
                    break;
            case SIG_PAL_M:
            case SIG_PAL_NC:
                    u8Value = 1;
                    break;
            default: // NTSC
                    u8Value = 2;
        }
        u8Ctl = ( u16Htotal - u8Value ) % 4;
        u8update =  1;
        if( u8Ctl == 3 )
            u16Htotal = u16Htotal + 1;
        else if( u8Ctl == 2 )
            u8update = 0;
        else
            u16Htotal = u16Htotal - u8Ctl;

        if( u8update )
        {
            MDrv_Write2Byte( BK_COMB_52, u16Htotal );
        }

        // Fix VD have large noise and use different Comb setting

        MDrv_WriteByte( BK_AFEC_04, 0x04 );

        u8Ctl = MDrv_ReadByte( BK_AFEC_02 ); // get VD Noise Magnitude
        if( u8Ctl >= 0x20 )
            u8Ctl = 0x20 ;
        if( u8Ctl != u8BackupNoiseMag )
        {
            u8BackupNoiseMag = ( u8Ctl + u8BackupNoiseMag + 1 ) >> 1;
            //ucValue = tVDtoCombTbl[g_ucBackupNoiseMag][0];
            //msWriteByte(BK6_31, ucValue);
            //ucValue = tVDtoCombTbl[g_ucBackupNoiseMag][1];
            u8Value = tVDtoCombTbl[u8BackupNoiseMag];
            u8Ctl = MDrv_ReadByte( BK_COMB_14 );
            MDrv_WriteByte( BK_COMB_14, (u8Ctl & 0xE0) | u8Value );
        }

        // Fix Comb bug
        u8Value = MDrv_ReadByte_SH( BK_AFEC_CC );

        if( !( u8Value & _BIT1 ) )
        {
            MDrv_WriteByte( BK_COMB_5A, 0x20 ); // No Burst (for hsync tolerance)

        }
        else
        {
            MDrv_WriteByte( BK_COMB_5A, 0x00); // Burst On
        }
    }

    {
        if( (MDrv_VD_GetStatus() & (VD_HSYNC_LOCKED|VD_MACROVISION|VD_STATUS_RDY)) ==
            (VD_HSYNC_LOCKED|VD_MACROVISION|VD_STATUS_RDY)
            )
        {
            MDrv_WriteRegBit( BK_COMB_40, ENABLE, _BIT2 );
        }
        else
        {
            MDrv_WriteRegBit( BK_COMB_40, DISABLE, _BIT2 );
        }
    }

    // for SECAM
    #if 0
    {
        if( MDrv_ReadRegBit( BK_AFEC_C9, _BIT1) )
        {
            MDrv_WriteByte( BK_SECAM_15, 0x3F );
        }
        else
        {
            MDrv_WriteByte( BK_SECAM_15, 0xBF );
        }
    }
    #endif

#ifdef PATCH_V_NONSTAND
    {
        U16 u16Vtotal;

        u16Vtotal = MDrv_Read2Byte_SH(BK_AFEC_C5); // Vtotal, already debounced
        if (u16Vtotal<514)
        {
            U8 u8Bank;
            U16 u16TempV_CapStart,u16OrgV_CapStart;
            u8Bank = MDrv_ReadByte(BK_SELECT_00);
            MDrv_WriteByte(BK_SELECT_00, REG_BANK_IP1F2);
            u16TempV_CapStart=g_SrcInfo.u16V_CapStart-(514-u16Vtotal);
            u16TempV_CapStart=(u16TempV_CapStart>5) ? u16TempV_CapStart : 5;
            u16OrgV_CapStart=MDrv_Read2Byte(BK_SC_IP1F2_04_L);
            if ( u16OrgV_CapStart != u16TempV_CapStart)
            {
                MDrv_Write2Byte(BK_SC_IP1F2_04_L, u16TempV_CapStart);
            }
            MDrv_WriteByte(BK_SELECT_00, u8Bank);
        }
    }
#endif
}


/******************************************************************************/
///Get VD status (VD AFEC & Comb)
///@return
///Status represented bits from VD
///- VD_PAL_SWITCH: BIT9
///- VD_COLOR_LOCKED: BIT10
///- VD_RESET_ON: BIT11
///- VD_VSYNC_50HZ: BIT12
///- VD_INTERLACED: BIT13
///- VD_HSYNC_LOCKED: BIT14
///- VD_SYNC_LOCKED: BIT15
///- VD_MACROVISION: BIT2
///- VD_VCR_MODE: BIT4
///- VD_FSC_3579: BIT6
///- VD_FSC_3575: BIT7
///- VD_FSC_3582: (BIT6|BIT7)
///- VD_FSC_4433: 0
///- VD_FSC_4285: BIT5
/******************************************************************************/
static U8 vDStatusBuf[2]; // <-<<<
static U8 vDStatusHangCnt; // <-<<<

U16 MDrv_VD_GetStatus ( void )
{
    U16 u16Status = 0x00;
    U8  u8BkAFEC_04;

    u8BkAFEC_04 = MDrv_ReadByte( BK_AFEC_04 ); //back up

    MDrv_WriteByte( BK_AFEC_04, 0x00 );
    u16Status = MDrv_Read2Byte_SH( BK_AFEC_CC );

    MDrv_WriteByte( BK_AFEC_04, u8BkAFEC_04 );


    { // <-<<<
        static U32 startHangTime;

        vDStatusBuf[0] = MDrv_ReadByte_SH(BK_AFEC_D6);

        if (vDStatusBuf[0] == vDStatusBuf[1])
        {
            if (vDStatusHangCnt > 0x02
            	&& MDrv_Timer_TimeDifferenceFromCurrent(startHangTime) > 30
            	)
            {
                DRVVD_DBG(printf (">>> ERROR: %04X, %02BX, %02BX <<<\r\n", vdResetCnt, vDStatusBuf[1]));
                MDrv_VD_McuReset(20);
            }
            else
            {
                DRVVD_DBG(printf ("- %02BX, %02BX\n", vDStatusHangCnt, vDStatusBuf[1]));
                vDStatusHangCnt++;
            }
        }
        else
        {
            vDStatusBuf[1] = vDStatusBuf[0];
            vDStatusHangCnt = 0;
            startHangTime = MDrv_Timer_GetTime0();
        }
    } // <-<<<

    DRVVD_DBG(printf("\r\nGet VD Status=%x", u16Status));
    return u16Status;
}

#if 0
/******************************************************************************/
///Get WSS information (VBI)
///@return
///WSS Information
/******************************************************************************/
U16 MDrv_VD_GetWSS( void )
{
    return u16WSSinfo;
}
#endif

/******************************************************************************/
///Set VD Default data
///@param pRegTable \b IN: Register table
/******************************************************************************/
void MDrv_VD_WriteRegTbl ( MS_REG_TYPE *pRegTable )
{
    U16 u16Index; // register index
    U16 u16Dummy;

    u16Dummy = 65535;
    while ( 1 )
    {
        u16Index = pRegTable->u16Index; // get register index

        if ( u16Index == _END_OF_TBL_ ) // check end of table
            break;

        MDrv_WriteByte( u16Index, pRegTable->u8Value ); // write register

        pRegTable++; // next

        if( (u16Dummy--) == 0 ) break;
    } // while
}

//************************************************************************
///reset VD mcu address to 0x0000
//*************************************************************************
void ResetVdMcuAddress(void)
{
    U16    TimeOut;

    XBYTE[VD_MCU_OFFSET_ADDR_0]=0x00;   //offset address=0x0000
    XBYTE[VD_MCU_OFFSET_ADDR_1]=0x80;
    for ( TimeOut=0;TimeOut<0xffff;TimeOut++ )
    {
        if ( (XBYTE[VD_MCU_OFFSET_ADDR_1] & 0x80 ) == 0x00 )
            break;
    }
}
/******************************************************************************/
///initialize video decoder registers
/******************************************************************************/
void MDrv_VD_RegInit ( void )
{
     U16 TimeOut;
    //Reset page address=0x0000
    XBYTE[VD_MCU_PAGE_ADDR]=0x20;   //reset page =0x00
    for ( TimeOut=0;TimeOut<0xffff;TimeOut++ )
    {
        if ( (XBYTE[VD_MCU_PAGE_ADDR] & 0x20 ) == 0x00 )
            break;
    }

    ResetVdMcuAddress();            //reset address=0x0000

/*// seven 070913_00
    #if (MST_XTAL_CLOCK_HZ == FREQ_14P318MHZ)// kevin e
    MDrv_Write2ByteA(0x3510, 0x1AB0);
    MDrv_Write2ByteA(0x3547, 0x1580);
    #elif (MST_XTAL_CLOCK_HZ == FREQ_12MHZ)
    MDrv_Write2ByteA(0x3510, 0x1CB0);
    MDrv_Write2ByteA(0x3547, 0x1980);
    #else
    #error "Wrong Divider setting A"
    #endif
// end*/

#if 1
    /******************
     *  ADC reg init
     ******************/
#else // #if 1
    MDrv_WriteByte(BK_ADC_12, 0x05);
    MDrv_WriteByte(BK_ADC_24, 0x00);
    //MDrv_WriteByte(BK_ADC_2F, 0x1F);test
    MDrv_WriteByte(BK_ADC_29, 0x03);
    MDrv_WriteByte(BK_ADC_3C, 0x01);
    MDrv_WriteByte(BK_ADC_40, 0x00);
#endif // #if 1

    MDrv_WriteByte(BK_AFEC_0A, 0x10);
    MDrv_WriteByte(BK_AFEC_0F, 0x48);
    MDrv_WriteByte(BK_AFEC_68, 0xDD);
    MDrv_WriteRegBit(BK_AFEC_14, ENABLE, _BIT7);
    MDrv_WriteRegBit(BK_AFEC_14, DISABLE, _BIT7);

// seven 070912_00
//    MDrv_WriteRegBit(BK_AFEC_B2, ENABLE, _BIT7); // patch Lola color stripe issue (ref Venus' VD driver)
// end

    MDrv_VD_WriteRegTbl( astVdDecInitialize ); // initialize video decoder

    MDrv_WriteByte( BK_VBI_70, 0x80); // enable VPS/WSS

    MDrv_WriteByteMask(BK_AFEC_39, 0x03, _BIT1 | _BIT0);

    MDrv_VD_Hsen_Set_Detect_Win (HSEN_NORMAL_DETECT_WIN_BEFORE_LOCK, HSEN_NORMAL_DETECT_WIN_AFTER_LOCK);
    MDrv_VD_Hsen_Set_Cntr_Before_Lock (HSEN_NORMAL_CNTR_FAIL_BEFORE_LOCK, HSEN_NORMAL_CNTR_SYNC_BEFORE_LOCK);
    MDrv_VD_Hsen_Set_Cntr_After_Lock (HSEN_NORMAL_CNTR_SYNC_AFTER_LOCK);

    u8BackupNoiseMag = 0x20;
    u8SVflag = 0;
    u8VideoSystem = SIG_NONE;
    u16DataH[0] = u16DataH[1] = u16DataH[2] = 910;//SIG_NTSC
    u8HtotalDebounce = 0;
    u16WSSinfo = 0;
    u8WSSinfoCount = 0;
}
//*************************************************************************
///VD_MCU Reset
///@param u16DelayTime \b IN: delay time after VD MCU reset
//*************************************************************************
void MDrv_VD_McuReset( U16 u16DelayTime )
{
#if 0
//    MDrv_WriteByte( VDMCU_MIU_MAP_CMD, 0x82 );
    XBYTE[VD_MCU_RESET]|=0x01;
    MDrv_Timer_Delayms( 30 );//50
//    MDrv_WriteByte( VDMCU_MIU_MAP_CMD, 0x02 );
    XBYTE[VD_MCU_RESET]&=0xfe;

    MDrv_Timer_Delayms( u16DelayTime );
#else
    vDStatusBuf[0] = 0; // <-<<<
    vDStatusBuf[1] = 0; // <-<<<
    vDStatusHangCnt = 0; // <-<<<

    // MDrv_Timer_Delayms(100);

    XBYTE[VD_MCU_RESET]|=0x01;
    MDrv_Timer_Delayms( 10 ); //30 //50
    XBYTE[VD_MCU_RESET]&=0xfe;

    MDrv_Timer_Delayms( u16DelayTime );
#endif
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//*************************************************************************
///VD Parametter Initial
//*************************************************************************
void MDrv_VD_Parameter_Initial( void )
{
    // !!! CHECK WHO CALL THIS FUNCTION !!!
}

//------------------------------------------------------------------------
//*************************************************************************
///load DSP code to VD MCU
//*************************************************************************
void MDrv_VD_LoadDSPCode( void )
{
    BINFORMAT BinInfo;


    BinInfo.B_ID = g_u16VdBinSel;
    if( MDrv_MIU_Get_BinInfo(&BinInfo) != PASS )
    {
        DRVVD_DBG( printf( "could not find VD binary on flash.\r\n" ) );
        return;
    }
    DRVVD_DBG( printf("\r\n vd_mcu address: %08LX, len: %08LX", BinInfo.B_FAddr, BinInfo.B_Len) );

    MDrv_VDMCU_Init( BinInfo.B_FAddr, 0x00000l, MemAlign(BinInfo.B_Len, 8) );