cne2ktv.c

这是一个SIGMA方案的PMP播放器的UCLINUX程序,可播放DVD,VCD,CD MP3...有很好的参考价值.

/******************************************************************************/
/*  cne2ktv.c : specific code for NE2000TV board
*  REALmagic Quasar Hardware Library
*  Created by Aurelia Popa-Radu
*  Copyright Sigma Designs Inc
*  Sigma Designs Proprietary and confidential
*  Created on 8/7/01
*  Description:
/******************************************************************************/

/****h* HwLib/CNE2000TV_Implementation
 * DESCRIPTION
 *  CNE2000TV implementation of the IDecoderBoard interface.
 * NE2000TV uses EM840X, EM9010, EM9038, AD7170, FS402 components to implement
 * analog overlay output, TV and SCART output, HDTV output.
 * Identified by HwLib reading MD5,MD4,MD3,MD2 pins  = 0110 (MDCFG_NE2000TV).
 * PIO0	- IIC Clock for EM9010, AD7170, Eeprom, FS402 - see PIO7 also
 * PIO1	- IIC Data for EM9010, AD7170, Eeprom, FS402 - see PIO7 also
 * PIO2 - shift register data
 * PIO3 - shift register clock
 * PIO4	- IIC Clock for EM9038
 * PIO5	- IIC Data for EM9038
 * PIO6 - shift register valid
 * PIO7 - if 0 enable PIO0 and PIO1 to be used like IIC for EM9010, AD7170, Eeprom 
 *        if 1 enable PIO0 and PIO1 to be used like IIC for EM9010, AD7170, Eeprom
 * NE2000TV has a 16 bits shift register to extend the PIOs:
 * Q0 - DVCLK_EN
 * Q1 - NO_LOOP
 * Q2 - SCART_EN
 * Q3 - SCART_16:9
 * Q4 - SEL_MUX
 * Q5 - EN_MUX0
 * Q6 - EN_MUX1
 * Q7 - CTRL_ENABLE
 * Q8 - DIGITAL_EN
 * Q9 - RGB - select both Focus and RGB for SCART only
 * Q10 - YSYNC_EN
 * Q11 - 480P
 * Implementation is based on CNE2000.
 * Specific implementation:
 * QRESULT CNE2000TV__SetVideoProperty(IDecoderBoard* pIDecoderBoard,
 * 	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 * QRESULT CNE2000TV__GetVideoProperty(IDecoderBoard* pIDecoderBoard,
 * 	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 * QRESULT CNE2000TV__HwReset(IDecoderBoard* pIDecoderBoard)
 * QRESULT CNE2000TV__SelectVClk(IDecoderBoard* pIDecoderBoard,
 * 	VCLK_TYPE Type, void* pContext, DWORD ContextSize)
 * QRESULT CNE2000TV__SelectOutputForVideo(IDecoderBoard* pIDecoderBoard, DWORD General_TvOut)
/******************************************************************************/
#include "pch.h"

#if defined NE2000TV_BRD

#include "cqsrbrd.h"
#define SHIFT_REGISTER_PIO_DATA		PIO2
#define SHIFT_REGISTER_PIO_CLOCK	PIO3
#define SHIFT_REGISTER_PIO_VLD		PIO6

#define Q0			0x0001	// DVCLK_EN
#define Q1			0x0002	// NO_LOOP
#define Q2			0x0004	// SCART_EN
#define Q3			0x0008	// SCART_16:9
#define Q4			0x0010	// SEL_MUX
#define Q5			0x0020	// EN_MUX0
#define Q6			0x0040	// EN_MUX1
#define Q7			0x0080	// CTRL_ENABLE

#define Q8			0x0100	// DIGITAL_EN
#define Q9			0x0200	// RGB - select both Focus and RGB for SCART only
#define Q10			0x0400	// YSYNC_EN
#define Q11			0x0800	// 480P
#define Q12			0x1000	// Not used yet
#define Q13			0x2000	// Not used yet
#define Q14			0x4000	// Not used yet
#define Q15			0x8000	// Not used yet

//								480P YSYNC RGB DIG CTR MX1 MX0 SLM 169 SCEN NLOOP DVCLK_EN
//	EEprom address.bit:			 8.5  8.7  8.6  -   -  8.1 8.0 8.2 8.4 8.3  -   -
//								 Q11  Q10  Q9  Q8* Q7  Q6  Q5  Q4* Q3  Q2  Q1  Q0
//------------------------------------------------------------------------------------------
#define NE2000TV_OUTPUT_MASK	(                  Q7         |Q4         |Q1 |Q0) // 0x0093
#define NE2000TV_VGA			(                  Q7         |Q4             |Q0) // 0x0091
#define NE2000TV_TV				(                  Q7                            ) // 0x0080
#define NE2000TV_HDTV			(                  Q7         |Q4         |Q1 |Q0) // 0x0093
//------------------------------------------------------------------------------------------
#define NE2000TV_FORMAT_MASK	(     Q10  |Q9        |Q6 |Q5                    ) // 0x0660
#define NE2000TV_TV_COMPOSITE	(                      Q6                        ) // 0x0040
#define NE2000TV_TV_RGB			(           Q9        |Q6                        ) // 0x0240
#define NE2000TV_TV_YUV			(                      Q6                        ) // 0x0040
#define NE2000TV_COMPOSITE		(                      Q6                        ) // 0x0040
#define NE2000TV_COMP_RGB		(     Q10  |Q9            |Q5                    ) // 0x0620
#define NE2000TV_COMP_YUV		(     Q10                 |Q5                    ) // 0x0420
#define NE2000TV_OUTPUT_OFF		(                      Q6 |Q5                    ) // 0x0060
//------------------------------------------------------------------------------------------
#define NE2000TV_STDTV_MASK		( Q11|Q10                                        ) // 0x0800
#define NE2000TV_STDTV_NTSC		(   0                                            ) // 0x0000
#define NE2000TV_STDTV_PAL		(   0                                            ) // 0x0000
#define NE2000TV_STDTV_480P		( Q11|Q10                                        ) // 0x0800
//------------------------------------------------------------------------------------------
#define NE2000TV_SCART_MASK		(                                  Q3 |Q2        ) // 0x000C
#define NE2000TV_SCART_4x3		(                                      Q2        ) // 0x0004
#define NE2000TV_SCART_16x9		(                                  Q3 |Q2        ) // 0x000C
#define NE2000TV_SCART_DIS		(                                       0        ) // 0x0000

/****f* HwLib/CNE2000TV__ShiftRegister
 * USAGE
 *	void CNE2000TV__ShiftRegister(IDecoderBoard* pIDecoderBoard, DWORD AndMask, DWORD OrMask)
 * DESCRIPTION
 *	CNE2000TV__ShiftRegister - used to set some PIOs(Input/Output pins) through a
 *	shift register present on some boards.
 * PARAMETERS
 *	IN IDecoderBoard* pIDecoderBoard - pointer to the board object
 *	IN DWORD AndMask - used to logical AND the previous shift register value. 
 *	IN DWORD OrMask - used to logical OR the result of AND:
 *			(PreviousShiftRegister & AndMask) | OrMask. 
/*****************************************************************************/
void CNE2000TV__ShiftRegister(IDecoderBoard* pIDecoderBoard, int AndMask, int OrMask)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	int i;
	DWORD Value = (this->RegControl & AndMask) | OrMask;
	if( this->RegControl == Value )
		return;

	this->RegControl = Value;

	// Q0 is LSB, Q15 is MSB
	QDbgLog((QLOG_TRACE, QDebugLevelError, TEXT(">>>ShiftRegister: %x"), Value));
	for(i=0;i<16;i++)
	{
		IDecoder_WritePIO(this->m_pIDecoder, SHIFT_REGISTER_PIO_CLOCK, 0 );	// clk=0
		IDecoder_WritePIO(this->m_pIDecoder, SHIFT_REGISTER_PIO_DATA, Value & 0x8000 );// data
		IDecoder_WritePIO(this->m_pIDecoder, SHIFT_REGISTER_PIO_CLOCK, 1 );	// clk=1
		Value = Value<<1;
	}
	IDecoder_WritePIO(this->m_pIDecoder, SHIFT_REGISTER_PIO_VLD, 0 );// vld=0
	OSTimeDelay(10);
	IDecoder_WritePIO(this->m_pIDecoder, SHIFT_REGISTER_PIO_VLD, 1 );// vld=1
}

void CNE2000TV__SetOutputFormat(IDecoderBoard* pIDecoderBoard, DWORD OutputFormat)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	DWORD ShiftRegister;
	this->ReqOutputFormat = OutputFormat;

	// default value. Must be overwritten.
	ShiftRegister = 0;

	if(this->TvOut == SET_TV)
	{
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("CNE2000TV__SetOutputFormat TvOut=%x - scan converter off"), this->TvOut ));
		// shut down the dacs of ScanConverter
		IScanConverter_SetOutputFormat(this->m_pIScanConverter, OUTPUT_OFF);
		switch (OutputFormat)
		{
		case COMPOSITE:
			ShiftRegister = NE2000TV_TV_COMPOSITE;
			break;
		case COMPONENT_RGB:
			ShiftRegister = NE2000TV_TV_RGB;
			break;
		case COMPONENT_YUV:
			ShiftRegister = NE2000TV_TV_YUV;
			break;
		case OUTPUT_OFF:
			return;
		}
	}
	else	// SET_VGA, SET_HDTV
	{
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("CNE2000TV__SetOutputFormat TvOut=%x - scan converter %x"), this->TvOut, OutputFormat ));
		// Set the Focus output
		IScanConverter_SetOutputFormat(this->m_pIScanConverter, OutputFormat);
		switch (OutputFormat)
		{
		case COMPOSITE:
			ShiftRegister = NE2000TV_COMPOSITE;
			break;
		case COMPONENT_RGB:
			ShiftRegister = NE2000TV_COMP_RGB;
			break;
		case COMPONENT_YUV:
			ShiftRegister = NE2000TV_COMP_YUV;
			break;
		case OUTPUT_OFF:
			ShiftRegister = NE2000TV_OUTPUT_OFF;
			break;
		}
	}

	CNE2000TV__ShiftRegister(pIDecoderBoard, ~NE2000TV_FORMAT_MASK, ShiftRegister);

	if( OutputFormat != OUTPUT_OFF )
	{
		// Set also the TV output
		ITvEncoder_SetCurrentYcYuvRgb(this->m_pIExtTv, OutputFormat);
		//?? ITvEncoder_SetCurrentYcYuvRgb(this->m_pISigmaTv, OutputFormat);
	}
}

void CNE2000TV__SetTVStandard(IDecoderBoard* pIDecoderBoard, DWORD TvStandard)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	DWORD dwOrMask;

	// default value. Must be overwritten.
	dwOrMask = 0;

	if(TvStandard == SET_NTSC)
		dwOrMask = NE2000TV_STDTV_NTSC;
	else if(TvStandard == SET_PAL)
		dwOrMask = NE2000TV_STDTV_PAL;
	else if(TvStandard == SET_480P)
		dwOrMask = NE2000TV_STDTV_480P;

	IScanConverter_SetTVStandard(this->m_pIScanConverter, TvStandard);
	CNE2000TV__ShiftRegister(pIDecoderBoard, ~NE2000TV_STDTV_MASK, dwOrMask);

	if( this->TvAsSource )
		return;

	if(TvStandard >= SET_480P)
		return;

	this->Standard_TvOut = TvStandard;
	if( this->TvOut == SET_TV )
	{
		// update TV hardware else next time when set to TV the TVstandard will be changed
		IDecoderBoard_VidSetVGATV(pIDecoderBoard, RST_DC | this->TvDacsState, this->TvOut);
	}
}

QRESULT CNE2000TV__SetVideoProperty(IDecoderBoard* pIDecoderBoard,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	// VIDEO use DWORD for changing information and size condition is already checked
	DWORD Value = *(DWORD*)pData;
	//	QRESULT qr = Q_OK;

	QDbgLog((QLOG_TRACE, QDebugLevelTrace,
		TEXT("   --> CNE2000TV__SetVideoProperty: set=%x id=%x flags=%x sz=%x value=%x"),
		PropSet, PropId, Flags, dwSizeIn, Value));

	switch(PropId)
	{
	case evScartOutput:
		this->ScartStatus = Value & SCART_MASK;
		switch(this->ScartStatus)
		{
		case SCART_COMPOSITE:
		case SCART_RGB:
			if (this->AspectRatio == VIDEO_ASPECT_RATIO_16_9)	// 16 x 9
				// Q2=SCTENB =1 - on, Q3=SCT169 =1 - 16:9
				CNE2000TV__ShiftRegister(pIDecoderBoard,
				~NE2000TV_SCART_MASK, NE2000TV_SCART_16x9);
			else	// 4x3
				// Q2=SCTENB =1 - on, Q3=SCT169 =0 - 4:3
				CNE2000TV__ShiftRegister(pIDecoderBoard,
				~NE2000TV_SCART_MASK, NE2000TV_SCART_4x3);
				break;

		case SCART_DISABLE:
			// Q2=SCTENB =0 - off, Q3=SCT169 =0 - 4:3
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~NE2000TV_SCART_MASK, NE2000TV_SCART_DIS);
			break;
		}
		break;

	case evTvOutputFormat:
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("\n   --> CNE2000TV__SetVideoProperty: evTvOutputFormat %x"), Value));
		CNE2000TV__SetOutputFormat(pIDecoderBoard, Value);
		break;

	case evTvStandard:
		CNE2000TV__SetTVStandard(pIDecoderBoard, Value);
		break;

	default:
		return CQuasarBoard__SetVideoProperty(pIDecoderBoard, PropSet, PropId, Flags, pData, dwSizeIn, pdwSizeOut);
	}
	return Q_OK;
}

QRESULT CNE2000TV__GetVideoProperty( IDecoderBoard* pIDecoderBoard,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;
	// VIDEO use DWORD for changing information and size condition is already checked
	DWORD Value;
	//	QRESULT qr = Q_OK;

	switch(PropId)
	{
	case evScartOutput:
		Value = this->ScartStatus;
		break;

	case evTvOutputFormat:
		if(this->TvOut == SET_TV)
			Value = this->ReqYcYuvRgb;
		else
			Value = this->ReqOutputFormat;
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("\n   <-- CNE2000TV__GetVideoProperty: evTvOutputFormat %x"), Value));
		break;

	default:
		return CQuasarBoard__GetVideoProperty(pIDecoderBoard, PropSet, PropId, Flags, pData, dwSizeIn, pdwSizeOut);
	}

	*(DWORD*)pData = Value;
	QDbgLog((QLOG_TRACE, QDebugLevelTrace,
		TEXT("   <-- CNE2000TV__GetVideoProperty: set=%x id=%x flags=%x sz=%x value=%x"),
		PropSet, PropId, Flags, dwSizeIn, Value));
	return Q_OK;
}

void CNE2000TV__InitShiftRegister(IDecoderBoard* pIDecoderBoard)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;

	if( !IEeprom_GetPresence( this->m_pIEeprom ) )
	{
		QDbgLog((QLOG_TRACE, QDebugLevelWarning, TEXT("InitShiftRegister: NO EEPROM on Board")));
		if(this->TvOut == SET_TV)
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			( NE2000TV_TV | NE2000TV_TV_COMPOSITE | NE2000TV_SCART_16x9) );
		}
		else if(this->TvOut == SET_HDTV)
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			( NE2000TV_HDTV | NE2000TV_COMPOSITE | NE2000TV_SCART_16x9) );
		}
		else	// VGA
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			( NE2000TV_VGA | NE2000TV_COMPOSITE | NE2000TV_SCART_16x9) );
		}
	}
	else
	{
		// information read from eeprom is defined in ns2kepr.h file
		BYTE EepromByte = 0;
		DWORD ShiftRegister = 0;
		//                    Bit0.........................Bit7
		//                   { Q5, Q6, Q4, Q2, Q3, Q11, Q9, Q10};
		DWORD EepromMap[8] = { Q5, Q6,  0, Q2, Q3, Q11, Q9, Q10};
		DWORD i;
		DWORD Value;

//		IEeprom_Read(this->m_pIEeprom, 8, &EepromByte);
		IEeprom_Read(this->m_pIEeprom, 0x1f, &EepromByte);
		EepromByte ^= 0x06;

		//EepromByte = 0x00;//for VGA composite, no scart
		//EepromByte = 0x18;//for VGA composite, scart 16x9
		//EepromByte = 0x1C;//for Tv composite, scart 16x9

		for (i=0;i<8;i++)
		{
			if( EepromByte & (1<<i) )
				ShiftRegister |= EepromMap[i];
		}
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("InitShiftRegister EepromByte0x1f= %x -> %x"), EepromByte, ShiftRegister));

		if(this->TvOut == SET_TV)
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			(NE2000TV_TV | ShiftRegister) );
		}
		else if(this->TvOut == SET_HDTV)
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			(NE2000TV_HDTV | ShiftRegister) );
		}
		else	// VGA
		{
			CNE2000TV__ShiftRegister(pIDecoderBoard,
			~( NE2000TV_OUTPUT_MASK | NE2000TV_FORMAT_MASK | NE2000TV_SCART_MASK),
			(NE2000TV_VGA | ShiftRegister) );
		}

		IEeprom_Read(this->m_pIEeprom, 9, &EepromByte);
		QDbgLog((QLOG_TRACE, QDebugLevelWarning,
			TEXT("InitShiftRegister EepromByte0x09= %x"), EepromByte ));