//----------------------------------------------------------------------------
// STMISC.C
//----------------------------------------------------------------------------
// Description :  All Video Register accesses are made in this File
//----------------------------------------------------------------------------
// Copyright SGS Thomson Microelectronics  !  Version alpha  !  Jan 1st, 1995
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                             Include files
//----------------------------------------------------------------------------
#include "stdefs.h"
#include "common.h"
#include "stvideo.h"
#include "STllapi.h"
#ifdef STi3520A
	#include "STi3520A.h"
#else
	#include "STi3520.h"
#endif
#include "debug.h"

//----------------------------------------------------------------------------
//                   GLOBAL Variables (avoid as possible)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                            Private Constants
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                              Private Types
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                     Private GLOBAL Variables (static)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                    Functions (statics one are private)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOL IsChipSTi3520(VOID)
{
	//---- Write STi3520 DCF register to 0
	VideoWrite(0x78, 0);
	VideoWrite(0x79, 0);

	//---- Read back DCF MSByte
	if (VideoRead(0x78) != 0)
		return FALSE; // we have red STi3520A VID_REV register
	else
		return TRUE;  // we have red STi3520 DCF register
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD SendAudioIfPossible(PVOID Buffer, WORD Size)
{
 DWORD NbSent;
 PAUDIO	pAudio;

 pAudio = pCard->pAudio;
 for(NbSent = 0 ; NbSent < Size ; NbSent++) {
	 if (pAudio->EnWrite)
		 AudioWrite(DATA_IN, *((PBYTE)Buffer)++);
	 else
		 break; // Audio Blocked
 }

 return NbSent;
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
WORD SendVideoIfPossible(PVOID Buffer, WORD Size)
{
	DebugAssert(Buffer != NULL);
	DebugAssert(Size != 0);

	if (VideoIsEnoughPlace(pCard->pVideo, Size)) {
		VideoSend((PDWORD)Buffer, Size);
		return Size;
	}

	return 0;
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetBBStart(PVIDEO pVideo, U16 bbg)
	{
	#ifndef STi3520A
	pVideo->currCommand|=BBGc;
	VideoWrite ( CMD, pVideo->currCommand >> 8 );// Initiate Write to Command
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );

	VideoWrite ( BBG, bbg >> 8 );// Initiate Write to Command
	VideoWrite ( BBG + 1,bbg & 0xFF );

	pVideo->currCommand&=~BBGc;
	VideoWrite ( CMD, pVideo->currCommand >> 8 );// Initiate Write to Command
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	#else
	VideoWrite ( VID_VBG, bbg >> 8 );// Initiate Write to Command
	VideoWrite ( VID_VBG + 1,bbg & 0xFF );
	#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
U16  VideoGetBBL(void)
	{
	U16		i;

	DisableIT();
	i = ( VideoRead ( BBL ) & 0x3F ) << 8;
	i = i | ( VideoRead ( BBL + 1 ) );
	EnableIT();
	return ( i );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetBBStop(U16 bbs)
	{
	VideoWrite ( BBS, bbs >> 8 );// Initiate Write to Command
	VideoWrite ( BBS + 1,bbs & 0xFF );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetBBThresh(U16 bbt)
	{
	VideoWrite ( BBT, bbt >> 8 );// Initiate Write to Command
	VideoWrite ( BBT + 1,bbt & 0xFF );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
U16  VideoBlockMove(PVIDEO pVideo, U32 SrcAddress, U32 DestAddress, U16 Size)// starts block move and waits for idle
	{
	U16 counter;
	#ifndef STi3520A
		// perform the block move from  SrcAddress area to DestAddress
	VideoWrite ( CMD, pVideo->currCommand >> 8 );
	VideoWrite ( CMD + 1, pVideo->currCommand | SBM );
	// set block move mode
	VideoSetMRP(SrcAddress);  // Set Source Address
	VideoSetMWP(DestAddress); // Set Destination Address
	VideoWrite ( BMS    , (Size >> 8) & 0xFF );   // 7FFC * 2 / 8 = 1FFF
	VideoWrite ( BMS + 1,  Size & 0xFF );
	counter = 0;
	while ( ! VideoBlockMoveIdle()  )
		{
		counter ++;
		if(counter == 0xFFFF)
				return ( BAD_MEM_V );
		}
	// wait for the end of the block move
	VideoWrite ( CMD, pVideo->currCommand >> 8 );
	VideoWrite ( CMD + 1, pVideo->currCommand & ~SBM );
	#else
	// set block move Size
	VideoWrite ( BMS    , (Size >> 8) & 0xFF );
	VideoWrite ( BMS 	,  Size & 0xFF );
	VideoSetMWP(DestAddress);
	VideoSetMRP(SrcAddress);            // Launches Block Move
	counter = 0;
	while ( ! VideoBlockMoveIdle()  )
		{
		counter ++;
		if(counter == 0xFFFF)
				return ( BAD_MEM_V );
		}
	// wait for the end of the block move
	#endif
	return ( NO_ERROR );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoStartBlockMove(PVIDEO pVideo, U32 SrcAddress, U32 DestAddress, U32 Size)// starts block move and returns
{
	SrcAddress = SrcAddress;
	DestAddress = DestAddress;
	Size = Size;
	#ifndef STi3520A
	#else
	#endif
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoCommandSkip(PVIDEO pVideo, U16 Nbpicture)// skips 1,or 2 pictures and decodes next
{
	DebugAssert(Nbpicture <= 2);

	if(Nbpicture > 2)
	{
		pVideo->errCode = ERR_SKIP;
	}
	else
	{
		#ifndef STi3520A
		#else
		#endif
	}
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetSRC(PVIDEO pVideo, U16 SrceSize, U16 DestSize)
	{
	U32 lsr;
		lsr = ( 256 * ( long ) ( SrceSize - 4 ) ) / (DestSize - 1);
	#ifndef STi3520A
		if ( lsr < 32 )
			lsr = 32;
		VideoWrite ( LSO, 0 );   // programmation of the SRC
		VideoWrite ( LSR, lsr );
		VideoWrite ( CSO, 0 );
		VideoWrite ( CSR, lsr );

	#else
		VideoWrite ( LSO, 0 );   // programmation of the SRC
		VideoWrite ( LSR, lsr );
		if(lsr > 255 )
			{
			 VideoWrite ( VID_LSRh, 1);
			}
		VideoWrite ( CSO, 0 );
	#endif
		VideoSRCOn ( pVideo );
	}

//----------------------------------------------------------------------------
// Load Quantization Matrix
//----------------------------------------------------------------------------
void VideoLoadQuantTables(PVIDEO pVideo, BOOLEAN Intra, U8 * Table )
	{
	U16 i; // loop counter
	#ifndef STi3520A
	VideoWrite ( CMD, pVideo->currCommand >> 8 );// Initiate Write to Command
	// Select Intra / Non Intra Table
	if(Intra)
		{
		pVideo->currCommand|=QMI;
		pVideo->currCommand&=~QMN;
		VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
		}
	else
		{
		pVideo->currCommand|=QMN;
		pVideo->currCommand&=~QMI;
		VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
		}
	// Enable Writing to Table
		pVideo->currCommand|=QMN;
		pVideo->currCommand|=QMI;
		VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	// Load Table
	for (i = 0 ; i < (QUANT_TAB_SIZE/2) ; i++) // 2 bytes loaded at each loop
		{
		VideoWrite(QMW , Table[2*i]);
		VideoWrite(QMW+1 , Table[2*i+1]);
		}
	// Lock Table Again
	pVideo->currCommand&=~QMN;
	pVideo->currCommand&=~QMI;
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	#else
	// Select Intra / Non Intra Table
	if(Intra)
		VideoWrite(VID_HDS,QMI);
	else
		VideoWrite(VID_HDS,(0&~QMI));
	// Load Table
	for (i = 0 ; i < QUANT_TAB_SIZE ; i++)
		VideoWrite(VID_QMW,Table[i]);
	// Lock Table Again
	VideoWrite(VID_HDS,0);
	#endif
	}

//----------------------------------------------------------------------------
//  Computes Instruction and stores in Ins1 Ins2 Cmd vars
//----------------------------------------------------------------------------
void VideoComputeInst(PVIDEO pVideo)
	{
	INSTRUCTION  Ins = pVideo->NextInstr;// Local var.
#ifndef STi3520A
pVideo->Cmd  = (pVideo->currCommand&0xFCFF)|(Ins.Skip << 4);
pVideo->Ins1 = (Ins.Tff<<15)|(Ins.Ovw<<14)|(Ins.Bfh<<10)|(Ins.Ffh<< 6)|
				 (Ins.Pct<< 4)|(Ins.Seq<< 3)|(Ins.Exe<< 2)|(Ins.Rpt<< 1)|(Ins.Cmv);
pVideo->Ins2 = (Ins.Pst<<14)|(Ins.Bfv<<10)|(Ins.Ffv<< 6)|(Ins.Dcp<< 4)|
				 (Ins.Frm <<3)|(Ins.Qst<< 2)|(Ins.Azz<< 1)|(Ins.Ivf);
#else
pVideo->Ppr1 = (Ins.Pct<< 4)|(Ins.Dcp<< 2)|(Ins.Pst );
pVideo->Ppr2 = (Ins.Tff<< 5)|(Ins.Frm<<4)|(Ins.Cmv<< 3)|(Ins.Qst<< 2)|
				 (Ins.Ivf<< 1)|(Ins.Azz   );
pVideo->Tis  = (Ins.Mp2<< 6)|(Ins.Skip<< 4)|(Ins.Ovw<< 3)|(Ins.Rpt<< 1)|
				 (Ins.Exe    );
pVideo->Pfh  = (Ins.Bfh<< 4)|(Ins.Ffh    );
pVideo->Pfv  = (Ins.Bfv<< 4)|(Ins.Ffv    );
#endif
}

//----------------------------------------------------------------------------
// put the decoder into WAIT mode
//----------------------------------------------------------------------------
/* This routine actually clears all bits of INS1/TIS registers

	This is not a problem since the whole registers HAVE to
	be rewritten when storing a new instruction.                 */
void    VideoWaitDec ( PVIDEO pVideo )
	{
#ifndef STi3520A
	VideoWrite ( CMD, 0 );
	VideoWrite ( CMD + 1, 0);
	// preset a write to INS1
	VideoWrite ( INS, 0 );
	VideoWrite ( INS + 1, 0);
	// not EXE
#else
	VideoWrite ( VID_TIS, 0 );
//if(pVideo->perFrame == TRUE)
//		{
		VideoChooseField(pVideo);// If Step by step decoding, set freeze bit
//		}
#endif

	}

//----------------------------------------------------------------------------
// starts a manual header search
//----------------------------------------------------------------------------
void VideoLaunchHeadSearch ( PVIDEO pVideo )
	{
#ifndef STi3520A
	VideoWrite ( CMD, pVideo->currCommand >> 8 );
	VideoWrite ( CMD + 1, pVideo->currCommand | 0x01 );
#else
	VideoWrite ( VID_HDS, HDS );
#endif
	}

//----------------------------------------------------------------------------
// Routine storing pVideo->nextInstr1 and 2 into the instruction registers
//----------------------------------------------------------------------------
void VideoStoreINS ( PVIDEO pVideo )
{
VideoComputeInst( pVideo) ;
#ifndef STi3520A
	VideoWrite ( CMD, pVideo->Cmd >> 8 );
	if ( pVideo->StreamInfo.modeMPEG2 )
	{
		VideoWrite ( CMD + 1, pVideo->Cmd | 0x8 );
		// preset a write to INS2
		VideoWrite ( INS, ( pVideo->Ins2 >> 8 ) );
		VideoWrite ( INS + 1, ( pVideo->Ins2 & 0xFF ) );
	}
	VideoWrite ( CMD + 1, pVideo->Cmd& 0xF7 );
	// preset a write to INS1
	VideoWrite ( INS, ( pVideo->Ins1 >> 8 ) );
	VideoWrite ( INS + 1, ( pVideo->Ins1 & 0xFF ) );
#else
	VideoWrite ( VID_TIS ,  pVideo->Tis  );
	VideoWrite ( VID_PPR1,  pVideo->Ppr1 );
	VideoWrite ( VID_PPR2,  pVideo->Ppr2 );
	VideoWrite ( VID_PFV ,  pVideo->Pfv  );
	VideoWrite ( VID_PFH ,  pVideo->Pfh  );
#endif
}

//----------------------------------------------------------------------------
//  Routine reading the number of bytes loaded in the CD_FIFO
//----------------------------------------------------------------------------
U32 VideoReadCDCount ( PVIDEO pVideo )
{
#ifndef STi3520A
	unsigned long   counter = 0;
	S16             i;

	DisableIT();

	pVideo->currCommand = pVideo->currCommand & 0xFCFF;		   // reset AVS bits
	VideoWrite ( CMD, ( pVideo->currCommand >> 8 ) | 0x1 );
	// access to CDcount[23:16]
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	counter = VideoRead ( CMD );
	i = VideoRead ( CMD + 1 ) & 0xFF;
	counter = ( unsigned long ) ( i ) << 16;	// contains
												// CDcount[23:16]
	VideoWrite ( CMD, pVideo->currCommand >> 8 );
	// access to CDcount[15:0]
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	i = ( VideoRead ( CMD ) << 8 ) | ( VideoRead ( CMD + 1 ) & 0xFF );
	counter = counter + ( ( unsigned long ) ( i ) & 0xFFFF );

	EnableIT(  );

	return ( counter );
#else
	U32 cd;
	DisableIT();

	cd  = ((U32)(VideoRead(CDcount)&0xFF))<<16;
	cd |= ((U32)(VideoRead(CDcount)&0xFF))<<8;
	cd |=  (U32)(VideoRead(CDcount)&0xFF);

	EnableIT(  );
	return ( cd );
#endif
}

//----------------------------------------------------------------------------
//  Routine reading the number of bytes extracted by the SCD
//----------------------------------------------------------------------------
U32   VideoReadSCDCount ( PVIDEO pVideo )
{
#ifndef STi3520A
	unsigned long   counter = 0;
	S16             i;

	DisableIT (  );

	pVideo->currCommand = pVideo->currCommand & 0xFCFF;		   // reset AVS bits
	VideoWrite ( CMD, ( pVideo->currCommand >> 8 ) | 0x3 );
	// access to SCDcount[23:16]
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	VideoRead ( CMD );
	i = VideoRead ( CMD + 1 ) & 0xFF;
	counter = ( unsigned long ) ( i ) << 16;	// contains
												// SCDcount[23:16]
	VideoWrite ( CMD, ( pVideo->currCommand >> 8 ) | 0x2 );
	// access to SCDcount[15:0]
	VideoWrite ( CMD + 1, pVideo->currCommand & 0xFF );
	i = ( VideoRead ( CMD ) << 8 ) | ( VideoRead ( CMD + 1 ) & 0xFF );
	counter = counter + ( ( unsigned long ) ( i ) & 0xFFFF );

	EnableIT (  );

	return ( counter );
#else
	U32 Scd;
	DisableIT (  );

	Scd  = ((U32)(VideoRead(SCDcount)&0xFF))<<16;
	Scd |= ((U32)(VideoRead(SCDcount)&0xFF))<<8;
	Scd |=  (U32)(VideoRead(SCDcount)&0xFF);

	EnableIT (  );
	return ( Scd );
#endif
}

//----------------------------------------------------------------------------
// DRAM I/O
//----------------------------------------------------------------------------
void VideoSetMWP(U32 mwp)
	{
	U8 m0, m1, m2;
#ifndef STi3520A
	m0 = (U8)( (mwp >> 16) & 0xFF );
	m1 = (U8)( (mwp >>  8) & 0xFF );
	m2 = (U8)(  mwp        & 0xFF );
	VideoWrite(MWP  , m0);
	VideoWrite(MWP+1, m1);
	VideoWrite(MWP+2, m2);
#else
	m0 = (U8)( (mwp >> 14) & 0xFF );
	m1 = (U8)( (mwp >>  6) & 0xFF );
	m2 = (U8)( (mwp <<  2) & 0xFF );
	VideoWrite(MWP  , m0);
	VideoWrite(MWP  , m1);
	VideoWrite(MWP  , m2);
#endif

	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetMRP(U32 mrp)
	{
	U8 m0, m1, m2;
#ifndef STi3520A
	m0 = (U8)( (mrp >> 16) & 0xFF );
	m1 = (U8)( (mrp >>  8) & 0xFF );
	m2 = (U8)(  mrp        & 0xFF );
	VideoWrite(MRP  , m0);
	VideoWrite(MRP+1, m1);
	VideoWrite(MRP+2, m2);
#else
	m0 = (U8)( (mrp >> 14) & 0xFF );
	m1 = (U8)( (mrp >>  6) & 0xFF );
	m2 = (U8)( (mrp <<  2) & 0xFF );
	VideoWrite(MRP  , m0);
	VideoWrite(MRP  , m1);
	VideoWrite(MRP  , m2);
#endif

	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOLEAN VideoMemWriteFifoEmpty( void )
	{
		return ( (VideoRead ( STA ) & 0x4) );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOLEAN VideoMemReadFifoFull( void )
	{
		return ( (VideoRead ( STA ) & 0x8) );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOLEAN VideoHeaderFifoEmpty( void )
	{
	VideoRead ( STA );
		return ( (VideoRead ( STA + 1 ) & 0x4) );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOLEAN VideoBlockMoveIdle( void )
	{
		return ( (VideoRead ( STA  ) & 0x20) );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoEnableDecoding(PVIDEO pVideo, BOOLEAN OnOff)
	{
	if(OnOff)
		pVideo->Ctl |= EDC;
	else
		pVideo->Ctl &= ~EDC;
#ifndef STi3520A
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1, pVideo->Ctl & 0xFF );
#else
	VideoWrite(CTL ,  pVideo->Ctl & 0xFF );
//CTL OK
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoEnableErrConc(PVIDEO pVideo, BOOLEAN OnOff)
	{
#ifndef STi3520A
	if(OnOff)
		pVideo->Ctl = (pVideo->Ctl |EPR)&~EDC;
	else
		pVideo->Ctl = (pVideo->Ctl&~EPR)|EDC;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	if(OnOff)
		pVideo->Ctl = (pVideo->Ctl |EPR|ERS|ERU)&~DEC;
	else
		pVideo->Ctl = (pVideo->Ctl&~EPR&~ERS&~ERU)|DEC;
	VideoWrite(CTL ,  pVideo->Ctl & 0xFF );
#endif
	}

//----------------------------------------------------------------------------
// pipeline RESET
//----------------------------------------------------------------------------
void VideoPipeReset ( PVIDEO pVideo )
	{
#ifndef STi3520A
	pVideo->Ctl |= PRS;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
	WaitMicroseconds(1000);
	pVideo->Ctl &= ~PRS;
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	pVideo->Ctl |= PRS;
	VideoWrite(CTL ,  pVideo->Ctl     );
	WaitMicroseconds(1000);
	pVideo->Ctl &= ~PRS;
	VideoWrite(CTL ,  pVideo->Ctl     );
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSoftReset ( PVIDEO pVideo  )
	{
#ifndef STi3520A
	pVideo->Ctl |= SRS;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
	WaitMicroseconds(1000);
	pVideo->Ctl = pVideo->Ctl&~ECK;
	VideoWrite(CTL + 1,  pVideo->Ctl     );
	pVideo->Ctl = pVideo->Ctl&~SRS;
	VideoWrite(CTL + 1,  pVideo->Ctl     );
	pVideo->Ctl = pVideo->Ctl|ECK;
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	pVideo->Ctl |= SRS;
	VideoWrite(CTL ,  pVideo->Ctl     );
//CTL OK
	WaitMicroseconds(1000);
	pVideo->Ctl &= ~SRS;
	VideoWrite(CTL ,  pVideo->Ctl     );
//CTL OK
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoEnableInterfaces ( PVIDEO pVideo, BOOLEAN OnOff )
	{
#ifndef STi3520A
	if(OnOff)
		pVideo->Ctl = pVideo->Ctl |EVI|EDI|ECK|EC2|EC3;
	else
		pVideo->Ctl = pVideo->Ctl&~EVI&~EDI&~ECK&~EC2&~EC3;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	if(OnOff)
		pVideo->Ccf = pVideo->Ccf |EVI|EDI|ECK|EC2|EC3;
	else
		pVideo->Ccf = pVideo->Ccf&~EVI&~EDI&~ECK&~EC2&~EC3;
	VideoWrite(CFG_CCF,pVideo->Ccf);
// CCF OK
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoPreventOvf( PVIDEO pVideo, BOOLEAN OnOff )
	{
#ifndef STi3520A
	if(OnOff)
		pVideo->Ctl = pVideo->Ctl |PBO;
	else
		pVideo->Ctl = pVideo->Ctl&~PBO;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	if(OnOff)
		pVideo->Ccf = pVideo->Ccf |PBO;
	else
		pVideo->Ccf = pVideo->Ccf&~PBO;
	VideoWrite(CFG_CCF,pVideo->Ccf);
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetFullRes( PVIDEO pVideo)
	{
	pVideo->HalfRes = FALSE;
#ifndef STi3520A
	pVideo->Ctl = pVideo->Ctl & ~HRD;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#endif
	pVideo->currDCF = pVideo->currDCF | pVideo->fullVerFilter;
	VideoWrite ( DCF, 0 );
	VideoWrite ( DCF + 1, pVideo->currDCF );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetHalfRes( PVIDEO pVideo)
	{
	pVideo->HalfRes = TRUE;
#ifndef STi3520A
	pVideo->Ctl = pVideo->Ctl |HRD;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#endif
	pVideo->currDCF = pVideo->currDCF | pVideo->halfVerFilter;
	VideoWrite ( DCF, 0 );
	VideoWrite ( DCF + 1, pVideo->currDCF );
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSelectMpeg2( PVIDEO pVideo , BOOLEAN OnOff)
	{
#ifndef STi3520A
	if(OnOff)
		pVideo->Ctl = pVideo->Ctl |MP2;
	else
		pVideo->Ctl = pVideo->Ctl&~MP2;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	if(OnOff)
		pVideo->NextInstr.Mp2 = 1;
	else
		pVideo->NextInstr.Mp2 = 0;
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSelect8M( PVIDEO pVideo , BOOLEAN OnOff)
	{
#ifndef STi3520A
	if(OnOff)
		pVideo->Ctl = pVideo->Ctl |S8M;
	else
		pVideo->Ctl = pVideo->Ctl&~S8M;
	VideoWrite(CTL    , (pVideo->Ctl>>8) );
	VideoWrite(CTL + 1,  pVideo->Ctl     );
#else
	if(OnOff)
		pVideo->Ccf = pVideo->Ccf |M32;
	else
		pVideo->Ccf = pVideo->Ccf&~M32;
	VideoWrite(CFG_CCF,pVideo->Ccf);
#endif
	}

//----------------------------------------------------------------------------
// GCF1 register Routines
//----------------------------------------------------------------------------
void VideoSetDramRefresh( PVIDEO pVideo, U16 Refresh)
	{
	pVideo->Gcf = pVideo->Gcf |(Refresh & RFI);
#ifndef STi3520A
	VideoWrite(GCF    , (pVideo->Gcf>>8) );
	VideoWrite(GCF + 1,  pVideo->Gcf     );
#else
	VideoWrite(CFG_MCF,pVideo->Gcf);
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSelect20M( PVIDEO pVideo, BOOLEAN OnOff)
	{
	if(OnOff)
		pVideo->Gcf = pVideo->Gcf | M20;
	else
		pVideo->Gcf = pVideo->Gcf &~M20;

#ifndef STi3520A
	VideoWrite(GCF    , (pVideo->Gcf>>8) );
	VideoWrite(GCF + 1,  pVideo->Gcf     );
#else
	VideoWrite(CFG_MCF,pVideo->Gcf);
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoSetDFA( PVIDEO pVideo, U16 dfa)
	{
#ifndef STi3520A
	pVideo->Gcf = pVideo->Gcf |(dfa & DFA);
	VideoWrite(GCF    , (pVideo->Gcf>>8) );
	VideoWrite(GCF + 1,  pVideo->Gcf     );
#else
	VideoWrite(VID_DFA , dfa>>8);
	VideoWrite(VID_DFA , dfa);
#endif
	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoEnableDisplay( PVIDEO pVideo )
	{
	pVideo->currDCF = pVideo->currDCF |0x20;
	VideoWrite ( DCF, 0 );
	VideoWrite ( DCF + 1, pVideo->currDCF );

	}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void VideoDisableDisplay( PVIDEO pVideo )
	{
	pVideo->currDCF = pVideo->currDCF &(~0x20);
	VideoWrite ( DCF, 0 );
	VideoWrite ( DCF + 1, pVideo->currDCF );

	}

//------------------------------- End of File --------------------------------