mode.cpp

Lido PXA270平台开发板的最新BSP,包括源代码

	/////DPFEXIT((L"<-PrimarySurfaceSetMode"));

	return (bRtn);
}


/*****************************************************************************
 FUNCTION	: 	InitializeModes
 PURPOSE	:	This function uses the configuration information gathered up
				to this point in the initialization process to build a mode
				table by looking at permutations of video modes and pixel
				formats against constriants.
 PARAMETERS	: 	
 RETURNS	: 	TRUE if OK else FALSE
*****************************************************************************/
BOOL MBX::InitializeModes(void)
{
	ULONG	ulSize, ulWidth=0, ulHeight=0, ulBpp=0;
	ULONG	ulRet, ulValue, ulType = 0;
	HKEY	hConfig = (HKEY)INVALID_HANDLE_VALUE;

	//////////DPFENTER((L"->InitializeModes"));

	// read the registry to get the mode width / height
	// Open key in the registry.
	//
	ulRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(POWERVR_REG_ROOT), 0, 0, &hConfig);
	if (ulRet == ERROR_SUCCESS)
	{
		// Read resolution overrides from registry, if they exists
		//
		ulSize = sizeof(ULONG);

		ulRet = RegQueryValueEx (hConfig, L"Width", 0, &ulType, (PUCHAR)&ulValue, &ulSize);
		if ((ulRet == ERROR_SUCCESS) && (ulType == REG_DWORD))		// Binary format
		{
			ulWidth = ulValue;
		}

		ulRet = RegQueryValueEx (hConfig, L"Height", 0, &ulType, (PUCHAR)&ulValue, &ulSize);
		if ((ulRet == ERROR_SUCCESS) && (ulType == REG_DWORD))		// Binary format
		{
			ulHeight = ulValue;
		}

		ulRet = RegQueryValueEx (hConfig, L"BitsPerPixel", 0, &ulType, (PUCHAR)&ulValue, &ulSize);
		if ((ulRet == ERROR_SUCCESS) && (ulType == REG_DWORD))		// Binary format
		{
			ulBpp = ulValue;
		}

		#ifdef ROTATE_ENABLE
		/* take this opportunity to check the rotate disable reg entry */
		ulRet = RegQueryValueEx (hConfig, L"DisableDynamicScreenRotation", 0, &ulType, (PUCHAR)&ulValue, &ulSize);
		if ((ulRet == ERROR_SUCCESS) && (ulType == REG_DWORD))		// Binary format
		{
			m_bDisableDynScrnRotation = ulValue;
		}
		#endif//ROTATE_ENABLE
	}
	else
	{
		DPFWARNING((L"DDI : RegOpenKeyEx(%s) failed - %d", TEXT(POWERVR_REG_ROOT), ulRet));
	}
	
	if (hConfig != INVALID_HANDLE_VALUE)
	{
		RegCloseKey(hConfig);
	}
	
	#ifdef DRV_VERIFIABLE
	if (m_sDrvVerify.ui32StructSize == sizeof(DRV_VERIFY))
	{
		ulWidth = m_sDrvVerify.ui32Width;
		ulHeight = m_sDrvVerify.ui32Height;
		ulBpp = m_sDrvVerify.ui32BitsPerPixel;
		
		#ifdef ROTATE_ENABLE
		if (m_sDrvVerify.bForceDynamicRotationOFF)
		{
			m_bDisableDynScrnRotation = 1;
		}
		else if (m_sDrvVerify.bForceDynamicRotationON)
		{
			m_bDisableDynScrnRotation = 0;
		}
		#endif//ROTATE_ENABLE
	}
	#endif//DRV_VERIFIABLE
	
	if (ulWidth != 0 && ulHeight != 0 && ulBpp != 0)
	{
		m_sEnumerateModesList.wCount = 1;
		m_sEnumerateModesList.psModeList = (PPDP_EnumTableEntry)AllocSharedMem (sizeof(PDP_EnumTableEntry));

		if (m_sEnumerateModesList.psModeList != NULL)
		{
			m_sEnumerateModesList.psModeList->wXRes    = (WORD)ulWidth;
			m_sEnumerateModesList.psModeList->wYRes    = (WORD)ulHeight;
			m_sEnumerateModesList.psModeList->byBPP    = (BYTE)ulBpp;
			m_sEnumerateModesList.psModeList->wStride  = (WORD)(ulWidth * ((ulBpp+1) >> 3));
			m_sEnumerateModesList.psModeList->wRefresh = 60;
		}
	}
	else
	{
		m_clDisplay.PDP_EnumerateModeList (&m_sEnumerateModesList);
	}

	/////DPFEXIT((L"<-InitializeModes"));

	if (m_sEnumerateModesList.wCount != 0)
	{
		return (TRUE);
	}
	else
	{
		return (FALSE);	// failed to get modes
	}
}


BOOL MBX::DeInitializeModes(void)
{
	#if HW_VERIFY
	m_clHwVer.DisableHwVerForMode();
	#endif /* #ifdef HW_VERIFY */

	// Free up the primary surface.
	if (m_pPrimarySurface && m_pPrimarySurface->Buffer() != NULL)
	{
		delete m_pPrimarySurface;
	}

	if (m_sEnumerateModesList.psModeList)
	{
		FreeSharedMem (m_sEnumerateModesList.psModeList);
		m_sEnumerateModesList.psModeList = NULL;
	}

	return (TRUE);
}


SCODE MBX::GetModeInfo(GPEMode *psMode, INT nModeNumber)
{
	GPEMode sModeInfo;

	DPFX(PVR_ZONE_INIT, (L"MBX::GetModeInfo"));

	if (nModeNumber >= m_sEnumerateModesList.wCount)
	{
		return (E_INVALIDARG);
	}

	PPDP_EnumTableEntry psModeEntry = &m_sEnumerateModesList.psModeList[nModeNumber];

	sModeInfo.Bpp = psModeEntry->byBPP;

#ifdef ROTATE_ENABLE

	switch (m_iRotate)
	{
		case DMDO_0:
			sModeInfo.width  = psModeEntry->wXRes;
			sModeInfo.height = psModeEntry->wYRes;
			m_lPrimaryRotation  = 0;
			break;

		case DMDO_90:
			sModeInfo.height = psModeEntry->wXRes;
			sModeInfo.width  = psModeEntry->wYRes;
			m_lPrimaryRotation  = 90;
			break;

		case DMDO_180:
			sModeInfo.width  = psModeEntry->wXRes;
			sModeInfo.height = psModeEntry->wYRes;
			m_lPrimaryRotation  = 180;
			break;
		case DMDO_270:
			sModeInfo.height = psModeEntry->wXRes;
			sModeInfo.width  = psModeEntry->wYRes;
			m_lPrimaryRotation  = 270;
			break;
	}
#else
	sModeInfo.width  = psModeEntry->wXRes;
	sModeInfo.height = psModeEntry->wYRes;
#endif

	sModeInfo.format    = GetDisplayModeGPEFormat(psModeEntry->byBPP);
	sModeInfo.frequency = psModeEntry->wRefresh;
	sModeInfo.modeId    = nModeNumber;

	*psMode = sModeInfo;

	return (S_OK);
}


int MBX::NumModes()
{
	DPFX(PVR_ZONE_INIT, (L"MBX::NumModes"));

	return (m_sEnumerateModesList.wCount);
}


#if defined PROFILE_ROTATION
void MBX::ProfileVidMemBlts(void)
{
	MemNode *psODFB1Mem, *psODFB2Mem, *psExtn1Mem, *psExtn2Mem;
	MemNode *psCallback = new MemNode( sizeof(ULONG), &m_sDevData, 4, FBALLOC_STRATEGY_INTN); 

	ULONG	ulSize, ulValue;
	ULONG	ulMaxSize = 512;
	ULONG	ulCntr = 0;
	ULONG	ulDuration;
	ULONG	ulTime, ulStartTime, ulTicksPerSec;
	double	fMps;

    LARGE_INTEGER   LargeInt;

	*(ULONG *)psCallback->m_psDevMemHandle->pvLinAddr = 0;

	psODFB1Mem = new MemNode (ulMaxSize * ulMaxSize, &m_sDevData, 4, FBALLOC_STRATEGY_INTN);
	psODFB2Mem = new MemNode (ulMaxSize * ulMaxSize, &m_sDevData, 4, FBALLOC_STRATEGY_INTN);
	psExtn1Mem = new MemNode (ulMaxSize * ulMaxSize, &m_sDevData, 4, FBALLOC_STRATEGY_EXTN);  
	psExtn2Mem = new MemNode (ulMaxSize * ulMaxSize, &m_sDevData, 4, FBALLOC_STRATEGY_EXTN);

	ULONG ulODFB1PhysBase = psODFB1Mem->m_psDevMemHandle->uiDevAddr.uiAddr;
	ULONG ulODFB2PhysBase = psODFB2Mem->m_psDevMemHandle->uiDevAddr.uiAddr;
	ULONG ulExtn1PhysBase = psExtn1Mem->m_psDevMemHandle->uiDevAddr.uiAddr;
	ULONG ulExtn2PhysBase = psExtn2Mem->m_psDevMemHandle->uiDevAddr.uiAddr;

	DPFINFO((L"ODFB1 Physical Address 0x%.8lX", ulODFB1PhysBase));
	DPFINFO((L"ODFB2 Physical Address 0x%.8lX", ulODFB2PhysBase));
	DPFINFO((L"Extn1 Physical Address 0x%.8lX", ulExtn1PhysBase));
	DPFINFO((L"Extn2 Physical Address 0x%.8lX", ulExtn2PhysBase));

	/* check if ODFB is enabled */
	/* obtained address of pMSysData->pvLinRegBaseAddr from marsys.c */
	ulValue = *(IMG_UINT32*)((IMG_UINT32)0x44C00304);

	ASSERT (ulValue == 3);

	*(ULONG *)psODFB1Mem->m_psDevMemHandle->pvLinAddr = 0x55555555;

	/* turn off ODFB and write new pattern */
	*(IMG_UINT32*)((IMG_UINT32)0x44C00304) = 0;
	*(ULONG *)psODFB1Mem->m_psDevMemHandle->pvLinAddr = 0xAAAAAAAA;
	ulValue = *(ULONG *)psODFB1Mem->m_psDevMemHandle->pvLinAddr;
	ASSERT (ulValue == 0xAAAAAAAA);

	/* turn on ODFB and read pattern */
	*(IMG_UINT32*)((IMG_UINT32)0x44C00304) = 3;
	ulValue = *(ULONG *)psODFB1Mem->m_psDevMemHandle->pvLinAddr;

	ASSERT (ulValue == 0x55555555);
	DPFINFO((L"ODFB IS active"));


	/* Calibrate to get ticks per sec */
	QueryPerformanceCounter (&LargeInt);
	ulStartTime = LargeInt.LowPart;

	ulTime = GetTickCount() + 1000;	/* wait 1 sec */

	while (GetTickCount() < ulTime);

	QueryPerformanceCounter (&LargeInt);
	ulTicksPerSec = LargeInt.LowPart - ulStartTime;

	DPFINFO((L"Ticks per Sec  %ld", ulTicksPerSec));

	
	PVRSRVAcquireSlavePort(m_sDevData.psDevInfoKM, PVRSRV_SLAVEPORT_2D, IMG_TRUE);

	for (ULONG ulRot = 1; ulRot <= 3; ulRot++)
	{
		DPFINFO ((L" Using a rotation of %d degrees", ulRot * 90));

		#ifdef PDUMP
		{
			char szBuf[80];
			sprintf(szBuf, "-- Using a rotation of %d degrees", ulRot * 90);
			PDumpScript(szBuf);
		}
		#endif

		for (ulSize = 8; ulSize <= ulMaxSize; ulSize = ulSize<<1)
		{
			/* blt from Extn1 to Extn2  src copy */
			ulDuration = DoTestBlt(ulExtn2PhysBase, ulExtn1PhysBase, ulSize, ulRot, psCallback->m_psDevMemHandle);
			fMps = (((double)ulTicksPerSec / (double)ulDuration) * ulSize * ulSize) / 1000000;
			DPFINFO((L"Extn1 -> Extn2\tImage size %d x %d bytes took %ld ticks,\t%.2f Mpps", ulSize, ulSize, ulDuration, fMps));

			/* blt from Extn2 to ODFB1  src copy */
			ulDuration = DoTestBlt(ulODFB1PhysBase, ulExtn2PhysBase, ulSize, ulRot, psCallback->m_psDevMemHandle);
			fMps = (((double)ulTicksPerSec / (double)ulDuration) * ulSize * ulSize) / 1000000;
			DPFINFO((L"Extn2 -> ODFB1\tImage size %d x %d bytes took %ld ticks,\t%.2f Mpps", ulSize, ulSize, ulDuration, fMps));

			/* blt from ODFB1 to ODFB2  src copy */
			ulDuration = DoTestBlt(ulODFB2PhysBase, ulODFB1PhysBase, ulSize, ulRot, psCallback->m_psDevMemHandle);
			fMps = (((double)ulTicksPerSec / (double)ulDuration) * ulSize * ulSize) / 1000000;
			DPFINFO((L"ODFB1 -> ODFB2\tImage size %d x %d bytes took %ld ticks,\t%.2f Mpps", ulSize, ulSize, ulDuration, fMps));

			/* blt from ODFB2 to Extn1  src copy */
			ulDuration = DoTestBlt(ulExtn1PhysBase, ulODFB2PhysBase, ulSize, ulRot, psCallback->m_psDevMemHandle);
			fMps = (((double)ulTicksPerSec / (double)ulDuration) * ulSize * ulSize) / 1000000;
			DPFINFO((L"ODFB2 -> Extn1\tImage size %d x %d bytes took %ld ticks,\t%.2f Mpps", ulSize, ulSize, ulDuration, fMps));
		}
	}

	PVRSRVReleaseSlavePort(	m_sDevData.psDevInfoKM, PVRSRV_SLAVEPORT_2D);

	delete psODFB1Mem;
	delete psODFB2Mem;
	delete psExtn1Mem;  
	delete psExtn2Mem;
	delete psCallback;
}

#define MAXREPEATTEST	1
ULONG MBX::DoTestBlt (ULONG ulDstPhysBase, ULONG ulSrcPhysBase, ULONG ulSize, ULONG ulRot, PVRSRV_MEM_INFO *psCallbackHandle)
{
    LARGE_INTEGER   LargeInt;
	ULONG			ulTimerStart;
	ULONG			ulCntr = *(volatile ULONG *)psCallbackHandle->pvLinAddr;

#ifdef PDUMP
	{
		char szBuf[80];
		sprintf(szBuf, "-- Src Blt size %d x %d from 0x%lX to 0x%lX", ulSize, ulSize, ulSrcPhysBase, ulDstPhysBase);
		PDumpScript(szBuf);
	}
#endif
	
	/* do prelim setup */
	SlavePortInitWrites();

	SlavePortWrite( MBX2D_STRETCH_BH 
				| (MBX2D_NO_STRETCH<<MBX2D_X_STRETCH_SHIFT)
				| (MBX2D_NO_STRETCH<<MBX2D_Y_STRETCH_SHIFT) );

#if 1
	/* SetDstSurf */
	SlavePortWrite( MBX2D_DST_CTRL_BH
					| 6<<15
					| ((ulSize<<MBX2D_DST_STRIDE_SHIFT)
						&	MBX2D_DST_STRIDE_MASK));

	SlavePortWrite((( ulDstPhysBase
					>>	MBX2D_DST_ADDR_ALIGNSHIFT)
					<<	MBX2D_DST_ADDR_SHIFT)
					&	MBX2D_DST_ADDR_MASK);

	/* SetScrSurf */
	SlavePortWrite( MBX2D_SRC_CTRL_BH
					| MBX2D_SRC_FBMEM
					| 6<<15
					| ((1<<MBX2D_SRC_STRIDE_SHIFT) 
						&	MBX2D_SRC_STRIDE_MASK) );

	SlavePortWrite((( ulSrcPhysBase
					>>	MBX2D_SRC_ADDR_ALIGNSHIFT)
					<<	MBX2D_SRC_ADDR_SHIFT)
					&	MBX2D_SRC_ADDR_MASK );


	QueryPerformanceCounter (&LargeInt);
	    
	ulTimerStart = LargeInt.LowPart;

	for (int nTimes = 0; nTimes < MAXREPEATTEST; nTimes++)
	{
		for (int nLine = 0; nLine < (int)ulSize; nLine++)
		{
			/* specify the starting pixel coordinate */
			SlavePortWrite( MBX2D_SRC_OFF_BH
							| ((0<<MBX2D_SRCOFF_XSTART_SHIFT) & MBX2D_SRCOFF_XSTART_MASK)
							| (((nLine * ulSize)<<MBX2D_SRCOFF_YSTART_SHIFT) & MBX2D_SRCOFF_YSTART_MASK) );

			/* let's do the blit */
			SlavePortWrite( MBX2D_BLIT_BH
							|	0xCCCC
							|	MBX2D_USE_FILL);

			SlavePortWrite( 0xFF & MBX2D_FILLCOLOUR_MASK);

			/* Write Destination rectangle to the Slave Port */
			SlavePortWrite( ((SHORT)0  &  MBX2D_DST_YSTART_MASK) |
							(((SHORT)(ulSize - nLine - 1 )<< MBX2D_DST_XSTART_SHIFT) & MBX2D_DST_XSTART_MASK) );

			SlavePortWrite( ((SHORT)ulSize & MBX2D_DST_YEND_MASK) |
						   (((SHORT)(ulSize - nLine) << MBX2D_DST_XEND_SHIFT) & MBX2D_DST_XEND_MASK) );

//			SlavePortFencedWrites();
		}

	}
#else
	/* SetDstSurf */
	SlavePortWrite( MBX2D_DST_CTRL_BH
					| 6<<15
					| ((ulSize<<MBX2D_DST_STRIDE_SHIFT)
						&	MBX2D_DST_STRIDE_MASK));

	SlavePortWrite((( ulDstPhysBase
					>>	MBX2D_DST_ADDR_ALIGNSHIFT)
					<<	MBX2D_DST_ADDR_SHIFT)
					&	MBX2D_DST_ADDR_MASK);

	/* SetScrSurf */
	SlavePortWrite( MBX2D_SRC_CTRL_BH
					| MBX2D_SRC_FBMEM
					| 6<<15
					| ((ulSize<<MBX2D_SRC_STRIDE_SHIFT) 
						&	MBX2D_SRC_STRIDE_MASK) );

	SlavePortWrite((( ulSrcPhysBase
					>>	MBX2D_SRC_ADDR_ALIGNSHIFT)
					<<	MBX2D_SRC_ADDR_SHIFT)
					&	MBX2D_SRC_ADDR_MASK );

	/* specify the starting pixel coordinate */
	SlavePortWrite( MBX2D_SRC_OFF_BH);

	QueryPerformanceCounter (&LargeInt);
	    
	ulTimerStart = LargeInt.LowPart;

	for (int nTimes = 0; nTimes < MAXREPEATTEST; nTimes++)
	{
		/* let's do the blit */
		SlavePortWrite( MBX2D_BLIT_BH
						|	0xCCCC
						|	MBX2D_USE_FILL
						|	ulRot<<25);

		SlavePortWrite( 0xFF & MBX2D_FILLCOLOUR_MASK);

		/* Write Destination rectangle to the Slave Port */
		SlavePortWrite( 0 );

		SlavePortWrite( ((SHORT)ulSize & MBX2D_DST_YEND_MASK) |
					   (((SHORT)ulSize << MBX2D_DST_XEND_SHIFT) & MBX2D_DST_XEND_MASK) );

//		SlavePortFlushWrites();
	}
#endif

	SurfaceUpdateBlit ( (IMG_UINT32)psCallbackHandle->uiDevAddr.uiAddr, ++ulCntr );

	while (ulCntr != *(volatile ULONG *)psCallbackHandle->pvLinAddr);

	QueryPerformanceCounter (&LargeInt);

	return ((LargeInt.LowPart - ulTimerStart) / MAXREPEATTEST);
}
#endif /* PROFILE_ROTATION */

/********************************** end of file ******************************/