mstar.c

MSTARXX.rar

            {
		        msWriteRegsTbl(tProgMsSvPort); // program SV port
		        msWriteByte(BK0_00_REGBK, REG_BANK2_VD);
                msWriteByteMask(BK2_1A_SVD_EN, 0xC0, 0xC0); // Enable SV
                msWriteBit(BK2_1F, 1, _BIT7); // Enable clamp C
                msWriteByte(BK2_7F,0x62);
                msWriteByte(BK0_00_REGBK, REG_BANK3_COMB);
                msWriteBit(BK3_10_COMBCFGA, 1, _BIT7); // Bypass comb
                msWriteBit(BK3_A1_SCM_IDSET1, 1, _BIT3); // Disable Secam-SV
            }
 	        msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);

            msVDCombLineBufferCtl( MSVD_COMB_LINE_BUFFER_CTL_HW_AUTO );

            #if TV_ENABLE
            if( IsTVInUse() )
            {
                hw_SetTunerOn();
                #if(!ENABLE_VCR_HANDLER)
                msWriteByte(BK0_00_REGBK, REG_BANK2_VD);
                msWriteByteMask(BK2_6A_VCR_DETECT1, 0x80, 0xC0); // 20051128.Eric.Lin: Force non-VCR mode
                #endif

                msWriteByte(BK0_00_REGBK, REG_BANK3_COMB);
                //msWriteByte( BK3_2F, 0x00 ); // IF_COEF for tuner input
                msWriteByte(BK3_24_TH2DHOR, 0x0A); // C-Trap disable: For PAL-DEM
                msWriteByteMask(BK3_21_COMB2DCFGB, 0x00, 0x08); //
            }
            else
            #endif
            {
                hw_SetTunerOff();
                #if(!ENABLE_VCR_HANDLER)
                msWriteByte(BK0_00_REGBK, REG_BANK2_VD);
                msWriteByteMask(BK2_6A_VCR_DETECT1, 0x40, 0xC0); // 20051128.Eric.Lin: Auto VCR mode
                #endif
                msWriteByte(BK0_00_REGBK, REG_BANK3_COMB);
                //msWriteByte( BK3_2F, 0x00 );
                msWriteByte(BK3_24_TH2DHOR, 0x20); // C-Trap disable: For PAL-DEM
                msWriteByteMask(BK3_21_COMB2DCFGB, 0x08, 0x08); //
            }
 	        msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
        }
    }

    msLineBufferDelayCtl( 0 ); // For Change source

/*
    if(!IsVGAInUse())
        msFieldDetectCtl();

#if SOG_ENABLE
        msFieldDetectCtl();
#endif
*/
    msFieldDetectCtl();

    if( IsVideoPortInUse())
    {
        #if(ENABLE_VD_DSP)
        //g_ucmsVDCtl |= MSVD_CTL_FLAG_VSYNC;
        #endif
        msVDReset(); // When change source
    }
    else
    {
        #if(ENABLE_VD_DSP)
        //g_ucmsVDCtl &= (~MSVD_CTL_FLAG_VSYNC);
        VD_DSP_Ctl( _DISABLE, 525 ); // Disable DSP
        #endif

        //if( g_ucmsVDCtl2&MSVD_CTL2_FLAG_AGC_PROCESSOR )
        VD_AGC_Ctl( 0 ); // Disable SW AGC
    }

	msSetUserPref();
    msWriteByte( BK0_00_REGBK, REG_BANK_SCALER);
}
//*******************************************************************
// Function Name: msPowerUp
//
// Decscription: Power on chip from power down mode
//
// callee: msWriteByte() in ms_rwreg.c
//
// caller: Power_PowerOnSystem() in power.c
//*******************************************************************
void msPowerUp(void)
{
  	msWriteByte(BK0_21_PLLCTRL2, 0); // power on master & output PLL
  	msWriteByte(BK0_E2_SWRST0, OP2R_B|ADCR_B); // reset graphic port RO register
  	msWriteByte(BK0_E2_SWRST0, 0);

    ChipPowerUpcontrol();

    Delay1ms(5);//(50);
    msWriteByte(BK0_00_REGBK, REG_BANK1_ADC_ACE_MCU); // switch to Bank 1

#if PANEL_ANALOG_TCON
    msWriteByte(BK1_A9_PD_VDAC, 0x00);
#else
    msWriteByte(BK1_4C, 0x5F);
#endif

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER); // switch to Bank 0
    Delay1ms(5);//(50);
    msWriteByte(BK0_F4_TRISTATE, 0);

#if ENABLE_MCU_USE_INTERNAL_CLOCK
    if( g_bMcuUseNewClock == 0 )
        McuUseInternalClock();
#endif
}

///////////////////////////////////////////////////////////////////////////////
// <Function>: msSoftwareReset
//
// <Description>: MST chip software reset.
//
// <Parameter>:  -  <Flow>  -  <Description>
//-----------------------------------------------------------------------------
// ucParam       -    In    -  Software reset parameter
// ucDelayTime   -    In    -  Delay time(unit: 1ms)
///////////////////////////////////////////////////////////////////////////////
void msSoftwareReset(BYTE wParam, BYTE ucDelayTime)
{
    msWriteByte(BK0_E2_SWRST0, wParam);
    Delay1ms(ucDelayTime);
    msWriteByte(BK0_E2_SWRST0, 0x00);
}

//*******************************************************************
// Function Name: msPowerDown
//
// Decscription: Power down chip
//
// callee: msWriteByte() in ms_rwreg.c
//
// caller: Power_PowerOffSystem() in power.c
//*******************************************************************
void msPowerDown(void)
{
    BYTE ucBank;
    ucBank = msReadByte(BK0_00_REGBK);
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
    #if ENABLE_MCU_USE_INTERNAL_CLOCK
    msWriteByte(BK0_EE_PDMD2, 0 );
    g_bMcuUseNewClock = 0;
    #endif

    msWriteByte(BK0_F4_TRISTATE, 0xFF);
    msWriteByte(BK0_00_REGBK, REG_BANK1_ADC_ACE_MCU); // switch to Bank 1
    msWriteByte(BK1_31, 0x7F);
    msWriteByte(BK1_32, 0xFF);

    msWriteByte(BK1_45, 0x01);

#if PANEL_ANALOG_TCON
    msWriteByte(BK1_A9_PD_VDAC, 0x0F);
#else
    msWriteByte(BK1_4C, 0x5F);
#endif

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER); // switch to Bank 0
    msWriteByte(BK0_E0_PDMD0, 0xB0);
    msWriteByte(BK0_E1_PDMD1, 0xFF);

    msWriteByte(BK0_00_REGBK, ucBank);

    TH1 = TIMER1_MODE2_TH1;      // set timer1(buad rate)
    TR1 = 1;    // timer1 run
    PX1 = 1; // set INT1 priority high      //Nicolee 20051231 add for low power mode ir power on set

    #if(IR_FORMAT == IR_RC5)
    PT2 = 1;
    #endif
}

void LoadGammaTbl(void)
{
    BYTE i;
    BYTE count;

    msWriteByte(BK0_91_GAMMA_ADR_PORT,0x00);
    msWriteByte(BK0_90_GAMMA_EN,msReadByte(BK0_90_GAMMA_EN)|_BIT1);
    for (i=0;i<3;i++)
    {
	    for(count=0;count<33;count++)
	        msWriteByte(BK0_92_GAMMA_DAT_PORT,tGammaTableNormal[i][count]);
    }
}

void msInitGamma(void)
{
    msWriteByte(BK0_90_GAMMA_EN, GAMMA_EN_B);
 	LoadGammaTbl();
}

void SystemDelay_translate_To_Dsp_Processor(BYTE wDelaycount)
{
	BYTE i;
	for( i = 0; i < wDelaycount; i ++ )
	{
	    Delay1ms(10);
	#if( ENABLE_VD_DSP&&((DSP_RUN_MODE == DSP_RUN_MODE_POLLING)||(DSP_RUN_MODE == DSP_RUN_MODE_TIMER_AND_POLLING)) )
	    //if( g_ucmsVDCtl & MSVD_CTL_FLAG_VSYNC )
	    {
	        VD_DSP();
	    }
	#endif
	}
}


WORD GetStdModeHFreq( BYTE ucModeIdx )
{
    return tStandardMode[ucModeIdx].HFreq;
}


WORD GetStdModeHTotal( BYTE ucModeIdx )
{
    if (tStandardModeResolution[tStandardMode[ucModeIdx].ResIndex].DispWidth < PanelWidth)
        return tStandardMode[ucModeIdx].HTotal* 2;
    else
    	return tStandardMode[ucModeIdx].HTotal;
}


WORD msCalculateHFreqX10( WORD wHPeriod )
{
    return ((((DWORD)MST_CLOCK_KHZ * 10) + (wHPeriod / 2)) / wHPeriod); // kHz
}


BYTE msCalculateVSyncTime(void)
{
    WORD wHFreqX10; // horizontal frequency

    wHFreqX10 = msCalculateHFreqX10( (WORD)msGetHorizontalPeriod() ); // calculate HSync frequency
    return (BYTE)((( (WORD)msGetVerticalTotal() * 10 ) + (wHFreqX10 / 2)) / wHFreqX10);
}

WORD msGetHorizontalPeriod(void)
{
    WORD wHorizontalPeriod;
    BYTE ucBank;

    ucBank = msReadByte( BK0_00_REGBK);
    msWriteByte( BK0_00_REGBK, REG_BANK_SCALER );
    wHorizontalPeriod = (msReadWord(BK0_EB_HSPRD_H) & MST_H_PERIOD_MASK);
    msWriteByte( BK0_00_REGBK, ucBank );
    return wHorizontalPeriod;
}

WORD msGetVerticalTotal(void)
{
    WORD wVerticalTotal;
    BYTE ucBank = msReadByte( BK0_00_REGBK);

    msWriteByte( BK0_00_REGBK, REG_BANK_SCALER );
    wVerticalTotal = (msReadWord(BK0_ED_VTOTAL_H) & MST_V_TOTAL_MASK);

    msWriteByte( BK0_00_REGBK, ucBank );
    return wVerticalTotal;
}

void GetInputSignalHV(void)
{
#if VGA_ENABLE
    if( IsVGAInUse()) // PC/YPbPr
    {
        g_InOutCtl.inHPeriod = g_wHorizontalPeriod;
        g_InOutCtl.inVTotal = g_wVerticalTotal;
    }
    else // CVBS/SV/656
#endif
    {
        g_InOutCtl.inHPeriod = msGetVideoHPeriod(2);
        g_InOutCtl.inVTotal = msVDGetVTotal();
    }
    g_InOutCtl.inHFreq = MST_CLOCK_HZ/g_InOutCtl.inHPeriod;
    g_InOutCtl.inOutVFreq = (g_InOutCtl.inHFreq+(g_InOutCtl.inVTotal/2))/g_InOutCtl.inVTotal;

    if( g_InOutCtl.bInterlace )
        g_InOutCtl.inOutVFreq *= 2;

    //printf("\r\n\r\ninHP=%d",g_InOutCtl.inHPeriod);
    //printf("\r\ninHF=%d",g_InOutCtl.inHFreq);
    //printf("\r\ninVT=%d",g_InOutCtl.inVTotal);
    //printf("\r\nInOutVFreq=%d", g_InOutCtl.inOutVFreq);
}

void msSetOutputSyncControl( BYTE ucOutputTimingCtl )
{
    BYTE ucBk0_57;

    ucBk0_57 = _BIT6; // Frame lock mode 1

#if (PANEL_SYNC_MODE_1)
    ucBk0_57 |= _BIT7; // Output v sync manually
#endif

#if (SCALING_FORMULA)
    ucBk0_57 |= _BIT2; // Scaling range add 1
#endif

    if( ucOutputTimingCtl&OUTPUT_FREERUN )
    {
        #if(ENABLE_CHECK_AUTO_H_TOTAL)
        g_bEnableAutoHTotal = 0;
        #endif
    }
    else
    {
        if( IsVGAInUse()) // PC/YPBPR
        {
            ucBk0_57 |= _BIT1;
            ucBk0_57 |= _BIT7;
        }
        else
        {
            #if(ENABLE_CHECK_AUTO_H_TOTAL)
            g_bEnableAutoHTotal = 0;
            #else
            ucBk0_57 |= _BIT1;
            #endif
        }
    }

    msWriteByte_Bank_BackupBank( REG_BANK_SCALER, BK0_57_OSCTRL1, ucBk0_57 );
}

void SetScalingRatio( BOOL bInterlace )
{
    BYTE ucBank; // bank buffer
    DWORD dwTemp;
    WORD wInputVSize;

    ucBank = msReadByte(BK0_00_REGBK); // store bank
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
/*
	printf("\r\nSCALING_H_IN=%d", SCALING_H_IN);
	printf("\r\nSCALING_H_OUT=%d", SCALING_H_OUT);
    printf("\r\nSCALING_V_IN=%d", SCALING_V_IN);
    printf("\r\nSCALING_V_OUT=%d", SCALING_V_OUT);
*/
    #if VGA_ENABLE
    if(IsVGAInUse())
	g_WindowInfo.V_DisSize = PanelHeight;
    else
    #endif
    g_WindowInfo.V_DisSize=PanelVSiEnd;

    // Horizontal
    if( SCALING_H_IN == SCALING_H_OUT )
    {
        dwTemp = 0;
        g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_NATIVE;
    }
    else
    {
        if( SCALING_H_IN < SCALING_H_OUT )
        {
            g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_UP;
            dwTemp = 0;
        }
        else // if( SCALING_H_IN > SCALING_H_OUT )
        {
            g_WindowInfo.H_SaclingRatioInfo = SCALING_RATIO_TYPE_DOWN;
            dwTemp = ScalingRatio_H( SCALING_H_IN, SCALING_H_OUT );

			//printf("ScalingRatio_H===%x", dwTemp/0x100); //get high 2 bytes
		if(IsVideoPortInUse())
		    dwTemp&=0xFFF000;
            if( dwTemp > 0xFF000 )
                dwTemp |= 0x800000;
            else
                dwTemp |= 0xC00000;
        }
    }
    msWrite3Bytes(BK0_32_SRH_H, dwTemp);

    // Vertical
    wInputVSize = SCALING_V_IN;

    if( bInterlace )
        wInputVSize = wInputVSize/2;

    if( wInputVSize == SCALING_V_OUT )
    {
        dwTemp = 0;
        g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_NATIVE;
    }
    else
    {
        if( wInputVSize < SCALING_V_OUT )
        {
            g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_UP;
        }
        else // ( wInputVSize > SCALING_V_OUT ) // Scaling down
        {
            g_WindowInfo.V_SaclingRatioInfo = SCALING_RATIO_TYPE_DOWN;
        #if(ENABLE_V_PRE_SCALING_DOWN)
            g_WindowInfo.V_SaclingRatioInfo |= SCALING_RATIO_FLAG_PRE;
        #endif
        }

    	#if (ENABLE_V_PRE_SCALING_DOWN)&&(!WidePanel)
        if( g_WindowInfo.V_SaclingRatioInfo&SCALING_RATIO_FLAG_PRE )
        {
            dwTemp = PRE_SCALING_RATIO_V( SCALING_V_IN, SCALING_V_OUT );
            if( bInterlace )
                dwTemp = dwTemp<<1;
            dwTemp |= 0xC00000;
        }
        else
    	#endif
        {
            dwTemp = ScalingRatio_V( SCALING_V_IN, SCALING_V_OUT );
            if( bInterlace )
                dwTemp = (dwTemp+1)>>1;

            if( dwTemp>0x3FFFFF)
            {
                dwTemp = 0x3FFFFF;
            }
            dwTemp &= 0x3FFFFF;
            dwTemp |= 0x800000;
        }
    }
    //printf("\r\nVScaleRatio=0x%xXX", dwTemp>>8);

    msWrite3Bytes(BK0_35_SRV_H, dwTemp);

#if(ENABLE_V_PRE_SCALING_DOWN)
    if ((g_WindowInfo.V_SaclingRatioInfo&SCALING_RATIO_FLAG_PRE) && (!bInterlace))
    {
        msWriteBit( BK0_C3, 1, _BIT6 );
    }
    else
    {
        msWriteBit( BK0_C3, 0, _BIT6 );
    }
#endif

    msWriteByte(BK0_00_REGBK, ucBank); // recovery bank
}

void CalculateAspectRatio(void)
{
#if(ENABLE_OVER_SCAN)
    WORD wTemp;
    BYTE ucOverScanH;
    BYTE ucOverScanV;

    // Get over scan ratio
    ucOverScanH = g_ucOverScanH;
    ucOverScanV = g_ucOverScanV;

    // Cal Over scan
    if( ucOverScanH )
    {
        wTemp = (DWORD)g_WindowInfo.H_CapSize * g_ucOverScanH / 1000;
        //g_WindowInfo.H_CapStart += wTemp;
        g_WindowInfo.H_CapSize = (g_WindowInfo.H_CapSize - 2 * wTemp);
    }

    if( ucOverScanV )
    {
        wTemp = (DWORD)g_WindowInfo.V_CapSize * g_ucOverScanV / 1000;
        //g_WindowInfo.V_CapStart += wTemp;
        g_WindowInfo.V_CapSize = (g_WindowInfo.V_CapSize - 2 * wTemp);
    }
#endif
}

void msSetupFreeRunMode( BYTE ucVFreq )
{
    BYTE ucBank; // bank buffer

    ucBank = msReadByte(BK0_00_REGBK); // backup bank
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
    //printf("\r\nSetFreeRunMode(%d)", ucVFreq);

    g_InOutCtl.inOutVFreq = ucVFreq;

    SetDisplayWindow();

    msSetOutputTiming( OUTPUT_FREERUN );
    msWriteRegsTbl(tFreeRunModeTbl);

    Set_FreeRunModeFlag();

    msWriteByte (BK0_00_REGBK, ucBank); // recovery bank
}

void msSetOutputTiming( BYTE ucOutputTimingCtl )
{
    BYTE ucBank; // bank buffer

    ucBank = msReadByte(BK0_00_REGBK); // store bank

    //printf("\r\nmsSetOutputTiming(%x)", ucOutputTimingCtl);

    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);

    msSetOutputSyncControl( ucOutputTimingCtl );

    if( ucOutputTimingCtl&OUTPUT_FREERUN )
    {
        msWriteWord(BK0_4F_VDTOT_H, PanelVTotal - 1);  // output vtotal
        msWriteWord(BK0_55_HDTOT_H, PanelHTotal - 1);  // output htotal
    }
    else
    {
        //msWriteWord(BK0_4F_VDTOT_H, 0x7FF); // output vtotal
    }

    SetOutputClock( ucOutputTimingCtl );

    msWriteByte(BK0_00_REGBK, ucBank);
}

void SetCaptureWindow()
{
    BYTE ucBank;