csm2288.c

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

/****f* HwLib/IMpegEncoder_GetHwIrqMask
 * USAGE
 *	DWORD IMpegEncoder_GetHwIrqMask(IMpegEncoder* pIMpegEncoder)
 *	DWORD Csm2288__GetHwIrqMask(IMpegEncoder* pIMpegEncoder)
 * DESCRIPTION
 *	IMpegEncoder_GetHwIrqMask returns the hardware IrqMask from register.
 * PARAMETERS
 *	IN IMpegEncoder* pIMpegEncoder - pointer to the encoder object
 * SEE ALSO
 *	IMpegEncoder_GetHwIrqStatus
/********************************************************************************************/
DWORD Csm2288__GetHwIrqMask(IMpegEncoder* pIMpegEncoder)
{
	return Csm2288__Read(pIMpegEncoder, SM2288_INT_EN_CTRL);
}

/****f* HwLib/IMpegEncoder_GetHwIrqStatus
 * USAGE
 *	DWORD IMpegEncoder_GetHwIrqStatus(IMpegEncoder* pIMpegEncoder)
 *	DWORD Csm2288__GetHwIrqStatus(IMpegEncoder* pIMpegEncoder)
 * DESCRIPTION
 *	IMpegEncoder_GetHwIrqStatus returns the current IrqStatus.
 * PARAMETERS
 *	IN IMpegEncoder* pIMpegEncoder - pointer to the encoder object
 * SEE ALSO
 *	IMpegEncoder_GetHwIrqMask
/********************************************************************************************/
DWORD Csm2288__GetHwIrqStatus(IMpegEncoder* pIMpegEncoder)
{
	return Csm2288__Read(pIMpegEncoder, SM2288_INT_INFO);
}

void Csm2288__InitPropertySet(IMpegEncoder* pIMpegEncoder, void* pPropSet, DWORD dwSize)
{
	Csm2288* this = (Csm2288*) pIMpegEncoder;
	if(dwSize != sizeof(PROPERTY_SET_ITEM))
		return;

	InitPropSet(pIMpegEncoder, pPropSet, MPEG_ENCODER_SET, emeMax,\
		this->MpegEncoderPropertyList, Csm2288__SetProperty, Csm2288__GetProperty)
}

/****f* HwLib/IMpegEncoder_SetProperty
 * USAGE
 *	QRESULT IMpegEncoder_SetProperty(IMpegEncoder* pIMpegEncoder,
 *		DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 *	QRESULT Csm2288__SetProperty(IMpegEncoder* pIMpegEncoder,
 *		DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 * PARAMETERS
 *	IN IMpegEncoder* pIMpegEncoder - pointer to the MpegEncoder object
/********************************************************************************************/
QRESULT Csm2288__SetProperty( IMpegEncoder* pIMpegEncoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	// MPEG_ENCODER_SET use DWORD for changing information and size condition is already checked
	Csm2288* this = (Csm2288*) pIMpegEncoder;
	DWORD Value = *(DWORD*)pData;

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

	switch(PropId)
	{
	case emeAccessRegister:
		{
		genericReg_type* p = (genericReg_type*)pData;
		CHECK_SIZE(genericReg)
		IMpegEncoder_Write(pIMpegEncoder, p->Addr, p->Data);
		}
		break;

	case emeXferUcodeParameters:
		{
		emeXferUcodeParameters_type* pXfer = (emeXferUcodeParameters_type*)pData;
		CHECK_SIZE(emeXferUcodeParameters)
		OSmemcpy(&this->XferUcodeParameters, pXfer,sizeof(emeXferUcodeParameters_type));
		}
		break;

	default:
		return E_NOT_SUPPORTED;
	}
	return Q_OK;
}

/****f* HwLib/IMpegEncoder_GetProperty 
 * USAGE
 *	QRESULT IMpegEncoder_GetProperty(IMpegEncoder* pIMpegEncoder,
 *		DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 *	QRESULT Csm2288__GetProperty(IMpegEncoder* pIMpegEncoder,
 *		DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
 * PARAMETERS
 *	IN IMpegEncoder* pIMpegEncoder - pointer to the MpegEncoder object
/********************************************************************************************/
QRESULT Csm2288__GetProperty( IMpegEncoder* pIMpegEncoder,
	DWORD PropSet, DWORD PropId, DWORD Flags, void* pData, DWORD dwSizeIn, DWORD* pdwSizeOut)
{
	Csm2288* this = (Csm2288*) pIMpegEncoder;
	DWORD Value;

	switch(PropId)
	{
	case emeAccessRegister:
		{
		genericReg_type* p = (genericReg_type*)pData;
		CHECK_SIZE(genericReg)
		p->Data = IMpegEncoder_Read(pIMpegEncoder, p->Addr);
		}
		return Q_OK;

	case emeXferUcodeParameters:
		{
		emeXferUcodeParameters_type* pXfer = (emeXferUcodeParameters_type*)pData;
		CHECK_SIZE(emeXferUcodeParameters)
		OSmemcpy(pXfer, &this->XferUcodeParameters, sizeof(emeXferUcodeParameters_type));
		}
		return Q_OK;
		
	default:
		return E_NOT_SUPPORTED;
	}

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


DWORD Csm2288__GetMicrocodeVersion(IMpegEncoder* pIMpegEncoder)
{
	Csm2288* this = (Csm2288*) pIMpegEncoder;
	return this->CurrentMicrocodeVersion;
}

QRESULT Csm2288__Test(IMpegEncoder* pIMpegEncoder,DWORD Command)
{
#ifdef WITH_SM2288_DIAG	

#define SM2288_CHECK_TIMEOUT_MS 5000 // full check lasts 2.3 seconds
#define TEST_PATTERN_1 0x9abc4321
#define TEST_PATTERN_2 0x74707570
#define CHUNKSIZE 1024 // either 1024 or 2048 (no other value)

	IMpegEncoder_HwReset(pIMpegEncoder,
			     SM2288DiagnosisUCode,sizeof(SM2288DiagnosisUCode),
			     NULL,0, // no parameters
			     INFO_SM_MASTER 
			     |INFO_SM_WAIT_TXFIFO);
	
	switch (Command) {
	case SM2288_SIMPLECHECK:
		QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: SIMPLECHECK begun")));
		
		QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: test pattern is 0x%08lx 0x%08lx"),TEST_PATTERN_1,TEST_PATTERN_2));
		
		IMpegEncoder_WriteCommand(pIMpegEncoder,SM2288_SIMPLECHECK,INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,HIWORD(TEST_PATTERN_1),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,LOWORD(TEST_PATTERN_1),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,HIWORD(TEST_PATTERN_2),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,LOWORD(TEST_PATTERN_2),0);
		
		{
			WORD answers[6]={0,};
			int i=0;
			DWORD timeleft=SM2288_CHECK_TIMEOUT_MS;
			
			while (1) {
				answers[i]=IMpegEncoder_ReadTXFifo(pIMpegEncoder,&timeleft);
				if (timeleft==0)  
					break;
				else {
					QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: answers[%d]=0x%04hx"),i,answers[i])); 
					i++;
				}
				
				if (i==6) break;
			}
			if (timeleft>0)
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: completed in %d ms"),SM2288_CHECK_TIMEOUT_MS-timeleft)); 
			else
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: timeout"))); 
			
			QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: SIMPLECHECK done")));
			
			return (
				(answers[1]==HIWORD(TEST_PATTERN_1))
				&&
				(answers[2]==LOWORD(TEST_PATTERN_1))
				&&
				(answers[3]==HIWORD(TEST_PATTERN_2))
				&&
				(answers[4]==LOWORD(TEST_PATTERN_2))
				&&
				(answers[5]==0xbeef)
				)?Q_OK:Q_FAIL;
		}
		break;
		
	case SM2288_FULLCHECK:
		QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: FULLCHECK begun")));
		
		QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: test pattern is 0x%08lx 0x%08lx 0x%04lx"),TEST_PATTERN_1,TEST_PATTERN_2,CHUNKSIZE));
		
		IMpegEncoder_WriteCommand(pIMpegEncoder,SM2288_FULLCHECK,INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,HIWORD(TEST_PATTERN_1),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,LOWORD(TEST_PATTERN_1),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,HIWORD(TEST_PATTERN_2),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,LOWORD(TEST_PATTERN_2),INFO_SM_WAIT_TXFIFO_CMD);
		IMpegEncoder_WriteCommand(pIMpegEncoder,CHUNKSIZE,0);
		
		{
			WORD answers[7]={0,};
			int i=0;
			DWORD timeleft=SM2288_CHECK_TIMEOUT_MS;
			
			while (1) {
				answers[i]=IMpegEncoder_ReadTXFifo(pIMpegEncoder,&timeleft);
				if (timeleft==0)  
					break;
				else {
					QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: answers[%d]=0x%04hx"),i,answers[i])); 
					i++;
				}
				
				if (i==7) break;
			}
			if (timeleft>0)
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: completed in %d ms"),SM2288_CHECK_TIMEOUT_MS-timeleft)); 
			else
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: timeout"))); 

			QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: FULLCHECK done")));
			
			return (
				(answers[1]==HIWORD(TEST_PATTERN_1))
				&&
				(answers[2]==LOWORD(TEST_PATTERN_1))
				&&
				(answers[3]==HIWORD(TEST_PATTERN_2))
				&&
				(answers[4]==LOWORD(TEST_PATTERN_2))
				&&
				(answers[5]==CHUNKSIZE)
				&&
				(answers[6]==0xbeef)
				)?Q_OK:Q_FAIL;
		}
		break;
		
	case SM2288_SIGNALCHECK:
		{
			DWORD timeleft=SM2288_CHECK_TIMEOUT_MS;
			DWORD temp;
			QRESULT rc;

			QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: SIGNALCHECK begun")));

			IMpegEncoder_WriteCommand(pIMpegEncoder,SM2288_SIGNALCHECK,0);
		
			temp=IMpegEncoder_ReadTXFifo(pIMpegEncoder,&timeleft);
			if (timeleft>0) {
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: %d vertical lines"),temp));
				rc=Q_OK;
			}
			else {
				QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: timeout")));
				rc=Q_FAIL;
			}
			
			QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: SIGNALCHECK done")));
			
			return rc;
		}
		break;
		
	default:
		QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: wrong diagnosis command")));
		return Q_FAIL;
		break;
	}
	
	return Q_OK;
	
#else
	
	QDbgLog((QLOG_TRACE,QDebugLevelError,TEXT("Csm2288__Test: diagnosis ucode not available")));
	return Q_FAIL;
		
#endif // WITH_SM2288_DIAG	
}

#include "cqsrbrd.h"
QRESULT CSm2288PvrBrd__EnableLBCInterrupt(IDecoderBoard* pIDecoderBoard, DWORD IrqMask)
{
	CQuasarBoard *this = (CQuasarBoard*) pIDecoderBoard;

	// enable Dma.. in H_INT falling edge interrupt directed to LBC_interrupt_reg bit 0
	IMpegEncoder_SetCurrentIrqMask(this->m_pIMpegEncoder, IrqMask);
	return Q_OK;
}

#else	// ! SM2288_OBJECT

void Csm2288__CreateInstance(void **ppv, DWORD dwInstance)
{
	*ppv = NULL;
}

#endif	// SM2288_OBJECT