memnodes.cpp

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

/***************************************************************************
 * Name        : memnodes.cpp
 * Title       : MBX WinCE driver GPE class
 * Author(s)   : Imagination Technologies
 * Created	   : 6th January 2003
 *
 * Copyright   : 2003 by Imagination Technologies. All rights reserved.
 *             : No part of this software, either material or conceptual 
 *             : may be copied or distributed, transmitted, transcribed,
 *             : stored in a retrieval system or translated into any 
 *             : human or computer language in any form by any means,
 *             : electronic, mechanical, manual or other-wise, or 
 *             : disclosed to third parties without the express written
 *             : permission of Imagination Technologies Limited, Unit 8,
 *             : HomePark Industrial Estate, King's Langley, Hertfordshire,
 *             : WD4 8LZ, U.K.
 *
 * Description : MBX WinCE driver GPE class.
 *
 * Platform    : WinCE
 *
 * Modifications:-
 * $Log: memnodes.cpp $
 *
 *  --- Revision Logs Removed --- 
 *
 *  --- Revision Logs Removed --- 
 *
 *  --- Revision Logs Removed --- 
 *
 ****************************************************************************/

#include	"precomp.h"

MemNode::MemNode ( ULONG ulBytes, PPVRSRV_DEV_DATA psDevData, ULONG ulAlignment, ULONG ulOptions )
{
	PVRSRV_MEM_INFO *psMemInfo;

	m_psDevData = psDevData;
	m_pbySysMemAddr = NULL;
	m_psDevMemHandle = NULL;
	m_pclNext = NULL;
	m_pclPrev = NULL;
	m_pclSurf = NULL;

#ifdef LOCAL_MEMORY_SELF_REFRESH //cskuo - no need - remove later
	SysLocalMemoryEnable(psDevData->psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH

	if (ulOptions == 0 || (ulOptions & FBALLOC_STRATEGY_INTN))
	{
		if ( PVRSRVAllocDeviceMem ( psDevData,
									PVRSRV_MEMFLG_CONTIGIOUS  | PVRSRV_MEMFLG_ALTERNATE_HEAP | PVRSRV_MEMFLG_NO_RESMAN,
									ulBytes,
									ulAlignment,
									&psMemInfo) == PVRSRV_OK )
		{
			m_psDevMemHandle = psMemInfo;
		}
	}

	if ((m_psDevMemHandle == NULL) &&
		(ulOptions == 0 || (ulOptions & FBALLOC_STRATEGY_EXTN)))
	{
		if ( PVRSRVAllocDeviceMem (psDevData,
								PVRSRV_MEMFLG_CONTIGIOUS | PVRSRV_MEMFLG_NO_RESMAN,
								ulBytes,
								ulAlignment,
								&psMemInfo) == PVRSRV_OK )
		{
			m_psDevMemHandle = psMemInfo;
		}
	}

#ifdef LOCAL_MEMORY_SELF_REFRESH
	SysLocalMemoryDisable(psDevData->psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH

}


MemNode::~MemNode()
{
	if (m_pclNext != NULL)
	{
		m_pclNext->m_pclPrev = m_pclPrev;
	}

	if (m_pclPrev != NULL)
	{
		m_pclPrev->m_pclNext = m_pclNext;
	}

	if(m_pbySysMemAddr != NULL)
	{
		LocalFree (m_pbySysMemAddr);
		m_pbySysMemAddr = NULL;
	}

	if (m_psDevMemHandle != NULL)
	{
		PVRSRVFreeDeviceMem (m_psDevData, m_psDevMemHandle);
	}
}

DevMemNode::DevMemNode()
{
	m_pbySaveMemAddr = (PBYTE)LocalAlloc(LMEM_FIXED, SAVE_BUFFER_SIZE);
}

DevMemNode::~DevMemNode ()
{
        DWORD FirstNode = 1;
	MemNode *pclNode = &m_clDevMemHeap, *pclNext;
	
	while (pclNode != NULL)
	{
		pclNext = pclNode->m_pclNext;

		/* Do not delete the first node in the list (it was 
		   not dynamically allocated). */
		if (FirstNode)
		{
		        FirstNode = 0;
		}
		else
		{
		        delete pclNode;
		}
		pclNode = pclNext;
	}
}


void	DevMemNode::AddToDevMemList (MemNode *pclNode)
{
	/* add entry just after the dummy first node */
	pclNode->m_pclNext = m_clDevMemHeap.m_pclNext;

	if (m_clDevMemHeap.m_pclNext != NULL)
	{
		m_clDevMemHeap.m_pclNext->m_pclPrev = pclNode;
	}

	m_clDevMemHeap.m_pclNext = pclNode;
	pclNode->m_pclPrev = &m_clDevMemHeap;
}


MemNode * DevMemNode::FindInDevMemList (LPVOID pvPtr)
{
	MemNode *pclNode;

	pclNode = &m_clDevMemHeap;
	while (pclNode)
	{
		if (pclNode->m_psDevMemHandle)
		{
			if ((LPVOID) pclNode->m_psDevMemHandle->pvLinAddr == pvPtr)
			{
				return (pclNode);
			}
		}

		pclNode = pclNode->m_pclNext;
	}

	return (NULL);
}


#if 0
MemNode *DevMemNode::UnlinkFromDevMemList (PVOID pvAddr)
{
	MemNode *pclNode;

	pclNode = &m_clDevMemHeap;

	while (pclNode)
	{
		if ((PVOID) pclNode->m_psDevMemHandle->pvLinAddr == pvAddr)
		{
			if (pclNode->m_pclPrev)
			{
				pclNode->m_pclPrev->m_pclNext = pclNode->m_pclNext;
			}

			if (pclNode->m_pclNext)
			{
				pclNode->m_pclNext->m_pclPrev = pclNode->m_pclPrev;
			}

			return (pclNode);
		}

		pclNode = pclNode->m_pclNext;
	}

	return (NULL);
}
#endif


BOOL DevMemNode::RestoreSystemMemtoSurf(void)
{
	MemNode *pclNode = &m_clDevMemHeap;
	DWORD dwMemIdx = 0;	// Index into our save buffer

	while (pclNode)		// Loop through all memory nodes.
	{
		if(pclNode->m_psDevMemHandle != NULL)
		{
			// First see if we had to allocate an individual buffer...
			if(pclNode->m_pbySysMemAddr != NULL)
			{
//				RETAILMSG(1, (L"Restoring from individual node!\r\n"));
				memcpy(pclNode->m_psDevMemHandle->pvLinAddr,
								pclNode->m_pbySysMemAddr,
								pclNode->m_psDevMemHandle->ui32AllocSize);
				// Free our individual buffer since it's served its purpose
				LocalFree(pclNode->m_pbySysMemAddr);
				pclNode->m_pbySysMemAddr = NULL;
			}
			// ... if it wasn't an individual buffer, see if we have a reserved buffer
			else if(m_pbySaveMemAddr != NULL)
			{
				memcpy(pclNode->m_psDevMemHandle->pvLinAddr,
								m_pbySaveMemAddr + dwMemIdx,
								pclNode->m_psDevMemHandle->ui32AllocSize);
				// Increment the next valid saved data
				dwMemIdx += pclNode->m_psDevMemHandle->ui32AllocSize;
			}
		}
		pclNode = pclNode->m_pclNext;	// Next node...
	}
	
	return (TRUE);
}


BOOL DevMemNode::SaveSurfToSystemMem   (void)
{
	MemNode *pclNode = &m_clDevMemHeap;
	DWORD dwMemIdx = 0;

	while (pclNode)	// Loop through all our memory nodes
	{
		if(pclNode->m_psDevMemHandle != NULL)	// Make sure it's valid
		{
			ASSERT(pclNode->m_pbySysMemAddr == NULL);
			pclNode->m_pbySysMemAddr = NULL;		// Ensure this is cleared
			// Need to make sure that this allocation will still fit in our reserved
			// buffer space.
			if((dwMemIdx + pclNode->m_psDevMemHandle->ui32AllocSize) >= SAVE_BUFFER_SIZE)
			{
//				RETAILMSG(1, (L"Save buffer wasn't big enough!!\r\n"));
				// Our previously reserved address wasn't big enough, so get some other memory
				pclNode->m_pbySysMemAddr = (PBYTE)LocalAlloc(LMEM_FIXED, pclNode->m_psDevMemHandle->ui32AllocSize);
				if(pclNode->m_pbySysMemAddr != NULL)
				{
					// Save the data we need into our reserved memory
					memcpy(pclNode->m_pbySysMemAddr,
								pclNode->m_psDevMemHandle->pvLinAddr,
								pclNode->m_psDevMemHandle->ui32AllocSize);
//					RETAILMSG(1, (L"Used individual node save buffer!\r\n"));
				}
				else
				{
//					RETAILMSG(1, (L"Failed to allocate individual save buffer!\r\n"));
					return FALSE;	// Might as well bail out here - we're hosed now.
				}
			}
			else if(m_pbySaveMemAddr != NULL)
			{
				// Copy the data into our reserved save buffer.
				memcpy(m_pbySaveMemAddr + dwMemIdx, 
								pclNode->m_psDevMemHandle->pvLinAddr, 
								pclNode->m_psDevMemHandle->ui32AllocSize);
				// Increment to the next available space to save things.
				dwMemIdx += pclNode->m_psDevMemHandle->ui32AllocSize;
			}
			else
			{
				RETAILMSG(1, (L"Nowhere to save data!\r\n"));
				return FALSE;
			}
		}
		pclNode = pclNode->m_pclNext;	// Next node
	}

	return (TRUE);
}


MBXSurf *DevMemNode::GetNextSurface (BOOL bFirst)
{
	if (bFirst)
	{
		m_pclCurrNode = &m_clDevMemHeap;
	}
	else if (m_pclCurrNode)
	{
		m_pclCurrNode = m_pclCurrNode->m_pclNext;
	}

	while (m_pclCurrNode)
	{
		if (m_pclCurrNode->m_pclSurf)
		{
			return (MBXSurf *)m_pclCurrNode->m_pclSurf;
		}
		m_pclCurrNode = m_pclCurrNode->m_pclNext;
	}

	return (NULL);
}

#ifdef DEBUG
void DevMemNode::DumpDevMemList (void)
{
	MemNode *pclNode;
	ULONG size = 0;

	pclNode = &m_clDevMemHeap;
	while (pclNode)
	{
		if (pclNode->m_psDevMemHandle)
		{
			DEBUGMSG ( 1, (TEXT("MemList: Phys Addr %.8lX, size %.8lX, LocalAlloc %.8lX"),
							pclNode->m_psDevMemHandle->uiDevAddr,
							pclNode->m_psDevMemHandle->ui32AllocSize,
							pclNode->m_pbySysMemAddr));
		}

		size += LocalSize(pclNode->m_pbySysMemAddr);

		if (pclNode->m_pclSurf)
		{
			MBXSurf *pclSurf = (MBXSurf *)pclNode->m_pclSurf;

			#ifdef ROTATE_ENABLE
			DEBUGMSG ( 1, (TEXT("\tMBX Surf %d x %d Rot Idx %d (%d)"),
						pclSurf->ScreenWidth(),
						pclSurf->ScreenHeight(),
						pclSurf->Rotate(), pclSurf->m_lRotationAngle));
			#else
			DEBUGMSG ( 1, (TEXT("\tMBX Surf %d x %d Rot Idx %d (%d)"),
						pclSurf->Width(),
						pclSurf->Height(),
						0, 0));
			#endif
		}

		pclNode = pclNode->m_pclNext;
	}
	DEBUGMSG ( 1, (TEXT("Total Local mem size: %X"), size));
}
#endif /* DEBUG */


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