// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <kernel/kern_priv.h>

 #include <graphics/surface.h>

 #include <graphics/surfacetypes.h>

 #include <graphics/surfacemanager.h>

 #include "surfacemanager_dev.h"

 #include <kernel/cache.h>

 /**

 Convert the surface Id to an index of the array 

 based on the least significant 4 bits of the first word of the ID

 @param	aSurfaceId  Const reference to the surface Id

 @internalTechnology

 */

 static TInt SurfaceIdToIndex(const TSurfaceId& aSurfaceId)

 	{

 	return static_cast<TInt>(aSurfaceId.iInternal[0]&(KMaxLists-1));

 	}

 /**

 Removes an item from a linked list

 @param	aList  Pointer to the head of a linked list of type T

 @param	aOwner  Pointer to the object to be removed

 @internalTechnology

 */

 template<class T>

 static void UnlinkListItem(T** aList, const T* aItem)

 	{

 	TRACE(Kern::Printf("SM UnlinkListItem list %08x  object %08x \n", aList, aItem);)

 	__ASSERT_DEBUG(aItem != NULL, Kern::Fault("Surface Manager", __LINE__));

 	__ASSERT_DEBUG(*aList != NULL, Kern::Fault("Surface Manager", __LINE__));

 	if (*aList == aItem)	//one we want is at the head of the list

 		{

 		*aList = aItem->iNext;

 		return;

 		}

 	T* p = *aList;

 	T* q = (*aList)->iNext;

 	while (q)

 		{

 		if (q == aItem)

 			{

 			p->iNext = q->iNext;

 			return;

 			}

 		p = q;

 		q = q->iNext;

 		}

 	}

 /**

 Returns a pointer to the surface owner object for the specified process, for this surface.

 @param	aProcess  Pointer to the process object

 @return pointer to the surface owner object if found, else NULL

 @internalTechnology

 */

 TProcessListItem* TSurface::ProcessOwnerInfo(const DProcess* aProcess)

 	{

 	TProcessListItem* so = iOwners;

 	while(so)

 		{

 		if (aProcess == so->iOwningProcess)

 			{

 			break;

 			}

 		so = so->iNext;

 		}

 	return so;

 	}

 /**

 Creates a shared chunk surface.

 @param aParams  Package buffer containing the surface creation parameters.  

 @param aId  Will be set to the surface id of the newly created surface.

 @return KErrNone if successful, KErrArgument if the creation attributes were incorrect,

 otherwise one of the other system wide error codes.

 @see RSurfaceManager::TSurfaceCreationAttributes

 @internalTechnology

 */

 TInt DSurfaceManager::CreateSurface(const TDesC8* aParams, TSurfaceId* aId)

 	{

 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

 	RSurfaceManager::TSurfaceCreationAttributes& attribs = buf();

 	Kern::KUDesGet(buf, *aParams);		//fetch input parameters

 	if( (attribs.iHintCount > KMaxHintsPerSurface) || (attribs.iHintCount<0) )

 		{

 		return KErrArgument;

 		}	

 	RSurfaceManager::THintPair tempSurfaceHints[KMaxHintsPerSurface];

 	if( (attribs.iHintCount>0) && attribs.iSurfaceHints)

 		{

 		kumemget(tempSurfaceHints, attribs.iSurfaceHints, attribs.iHintCount*sizeof(RSurfaceManager::THintPair));		

 		attribs.iSurfaceHints = tempSurfaceHints;

 		}

 	else

 		{

 		attribs.iSurfaceHints=NULL;

 		}

 	//validate input parameters and calculate chunk size

 	TInt roundedBufferSize = attribs.iOffsetBetweenBuffers;

 	TUint dummyActualSize = 0;	

 	TInt chunkSize = ValidateAndCalculateChunkSize(attribs, roundedBufferSize, dummyActualSize, ETrue);

 	if (chunkSize == 0)

 		{

 		return KErrArgument;

 		}	

 	TSurfaceId sid;

 	TInt r = KErrNone;

 	TSurface* surface = NULL;

 	do		//in the unlikely event that we generate a duplicate surface id, try again.

 		{

 		GenerateSurfaceId(sid);

 		NKern::FMWait(&iMutex);

 		surface = FindSurfaceById(sid);

 		NKern::FMSignal(&iMutex);

 		}

 	while (surface);

 	//create a shared chunk for the surface memory

 	TChunkCreateInfo info;

 	info.iType = TChunkCreateInfo::ESharedKernelMultiple;	//multi process mappable

 	info.iMaxSize = chunkSize;

 	info.iOwnsMemory = ETrue;

 //iMapAttr is valid only for hardware devices and will not make any effect in wins	

 #ifndef __WINS__

 	info.iMapAttr = (attribs.iCacheAttrib == RSurfaceManager::ECached) ? EMapAttrCachedMax : EMapAttrL1Uncached;

 #else

 	info.iMapAttr = 0;

 #endif

 	TLinAddr kernAddr;

 	TUint32 mapAttr;	

 	NKern::ThreadEnterCS();

 	DChunk* chunk;

 	r = Kern::ChunkCreate(info, chunk, kernAddr, mapAttr);

 	if (KErrNone != r)

 		{

 		NKern::ThreadLeaveCS();

 		return r;

 		}

 	//commit the memory

 	TUint32 paddr;

 	if (attribs.iContiguous)

 		{

 		r = Kern::ChunkCommitContiguous(chunk, 0, chunkSize, paddr);

 		}

 	else

 		{

 		r = Kern::ChunkCommit(chunk, 0, chunkSize);

 		}

 	if (KErrNone != r)

 		{

 		//problem committing the memory,

 		//destroy the chunk and cleanup

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		return r;

 		}

 	//create a surface structure for the new surface

 	surface = new TSurface;

 	TRACE(Kern::Printf("SM A %08x TSurface CreateSurface",surface);)

 	if (!surface)

 		{

 		//destroy the chunk and cleanup, out of memory

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		return KErrNoMemory;

 		}

 	surface->iId = sid;

 	surface->iSize = attribs.iSize;

 	surface->iBuffers = attribs.iBuffers;

 	surface->iPixelFormat = attribs.iPixelFormat;

 	surface->iStride = attribs.iStride;

 	surface->iOffsetToFirstBuffer = attribs.iOffsetToFirstBuffer;

 	surface->iAlignment = attribs.iAlignment;

 	surface->iContiguous = attribs.iContiguous;

 	surface->iChunk = chunk;

 	surface->iOffsetBetweenBuffers = roundedBufferSize;

 	surface->iCacheAttrib = attribs.iCacheAttrib;

 	surface->iMappable = attribs.iMappable;

 	if(attribs.iHintCount>0)

 		{

 		memcpy(surface->iSurfaceHints,tempSurfaceHints,attribs.iHintCount*sizeof(RSurfaceManager::THintPair));

 		}

 	memclr(surface->iSurfaceHints+attribs.iHintCount, (KMaxHintsPerSurface-attribs.iHintCount)*sizeof(RSurfaceManager::THintPair));

 	//create a surface owner for this surface

 	TProcessListItem* owner = new TProcessListItem;

 	TRACE(Kern::Printf("SM A %08x TProcessListItem CreateSurface",owner);)

 	if (!owner)

 		{

 		//destroy the chunk and cleanup, out of memory

 		Kern::ChunkClose(chunk);

 		delete(surface);

 		TRACE(Kern::Printf("SM D %08x TSurface CreateSurface",surface);)

 		NKern::ThreadLeaveCS();

 		return KErrNoMemory;

 		}

 	owner->iCount = 1;		//mark it as open in this process

 	owner->iOwningProcess =  &Kern::CurrentProcess();

 	owner->iNext = NULL;

 	surface->iOwners = owner;	//only 1 owner at creation time

 	//at this point we have a fully constructed TSurface

 	//add surface to head of surfaces list

 	NKern::FMWait(&iMutex);

 	//Mask off the bottom log2(KMaxLists) bits of the first word of the surfaceID as an index

 	//add the new surface to the beginning of the list 

 	TInt index = SurfaceIdToIndex(sid);

 	surface->iNext = iSurfacesIndex[index];

 	iSurfacesIndex[index] = surface;

 	NKern::FMSignal(&iMutex);		

 	NKern::ThreadLeaveCS();

 	//write surface id back to user side

 	kumemput(aId, &sid, sizeof (TSurfaceId));

 	return KErrNone;

 	}

 /**

 Validate that a chunk contains physical memory for the used areas.

 This function should be called in Critical Section in order to be completed even if the thread 

 or process is killed and so be able to free the memory allocated  (TUint32[pageList])

 @param aChunk  Chunk that the user supplied.   

 @param aAttribs  Surface Creation Attributes.

 @param aBuffersize  Calculated size of each buffer.

 @param aMapAttr  Filled in with the mapping attributes of the memory.

 @param aIsContiguous  Lets the caller know if the surface is physically contiguous or not. 

 @return KErrNone if successful, KErrArgument if the creation attributes were incorrect,

 KErrBadHandle if aChunkHandle is of an invalid shared chunk memory,

 otherwise one of the other system wide error codes.

 @see RSurfaceManager::TSurfaceCreationAttributes

 @internalTechnology

 */

 TInt DSurfaceManager::ValidatePhysicalMemory(DChunk* aChunk, const RSurfaceManager::TSurfaceCreationAttributes& aAttribs, 

 								   TUint aBuffersize, TUint32& aMapAttr, TBool &aIsContiguous) 

 	{

 	TLinAddr kernAddr;

 	TUint32 physAddr;

 	//Get the physical address for a region in a shared chunk

 	TInt pageSize = Kern::RoundToPageSize(1);

 	TInt pageList = 1 + (aChunk->iSize + pageSize - 2) / pageSize;

 	TUint32* physAddr2 = new TUint32[pageList];

 	if(!physAddr2)

 		{

 		return KErrNoMemory;

 		}

 	// Unless proven otherwise, the memory is not contiguous. 

 	aIsContiguous = EFalse;

 	TInt r = Kern::ChunkPhysicalAddress(aChunk, 0, aChunk->iSize, kernAddr, aMapAttr, physAddr, physAddr2);

 	if (KErrNone == r)

 		{

 		aIsContiguous = ETrue;

 		}

 	TRACE(Kern::Printf("SM CreateSurface ChunkPhysicalAddress r %d chunk %08x chunk size %d", r, aChunk, aChunk->iSize);)

 	TRACE(Kern::Printf("SM CreateSurface kernAddr %08x", kernAddr);)

 	TRACE(Kern::Printf("SM CreateSurface mapAttr %08x", aMapAttr);)

 	TRACE(Kern::Printf("SM CreateSurface physAddr %08x", physAddr);)

 	TRACE(Kern::Printf("SM CreateSurface physAddr2 %08x", physAddr2);)

 	if(r < KErrNone)

 		{

 		// Error means that there isn't memory in the whole chunk - so check the

 		// relevant areas - it is allowed to have gaps between the buffers, but not 

 		// within the actual regions that are used for buffers. 

 		// So, we first check the area before first buffer up to "offsettofirstbuffer", which all should be valid

 		if (aAttribs.iOffsetToFirstBuffer != 0)

 			{

 			r = Kern::ChunkPhysicalAddress(aChunk, 0, aAttribs.iOffsetToFirstBuffer, 

 					kernAddr, aMapAttr, physAddr, physAddr2);

 			}

 		else

 			{

 			r = KErrNone;

 			}

 		// If that's a pass, loop through and check the actual buffers (leave loop if it fails).

 		for(TInt i = 0; i < aAttribs.iBuffers && KErrNone <= r; i++)

 			{

 			r = Kern::ChunkPhysicalAddress(aChunk, 

 					aAttribs.iOffsetToFirstBuffer + aAttribs.iOffsetBetweenBuffers * i, 

 					aBuffersize, kernAddr, aMapAttr, physAddr, physAddr2);

 			}

 		}

 	// Fix up weird ChunkPhysicalAddress behaviour - it returns 1 to indicate that memory is non-contiguous. 

 	if (1 == r)

 		{

 		r = KErrNone;

 		}

 	delete[] physAddr2;

 	return r;

 	}

 /**

 Creates a surface in an existing shared chunk.

 @param aParam  Package buf containing the surface creation parameters and id to be set to the surface id of the newly created surface.  

 @param aChunkHandle  Existing valid shared chunk handle.

 @return KErrNone if successful, KErrArgument if the creation attributes were incorrect,

 KErrBadHandle if aChunkHandle is of an invalid shared chunk memory,

 otherwise one of the other system wide error codes.

 @see RSurfaceManager::TSurfaceCreationAttributes

 @internalTechnology

 */

 TInt DSurfaceManager::CreateSurface(RSurfaceManagerDriver::TDeviceParam* aParam, TInt aChunkHandle)

 	{

 	RSurfaceManager::TSurfaceCreationAttributesBuf buf;

 	RSurfaceManager::TSurfaceCreationAttributes& attribs = buf();

 	//Get the input parameters

 	RSurfaceManagerDriver::TDeviceParam param;

 	kumemget(&param, aParam, sizeof(RSurfaceManagerDriver::TDeviceParam));

 	Kern::KUDesGet(buf, *(reinterpret_cast<const TDesC8*>(param.iBuffer)));

 	if( (attribs.iHintCount > KMaxHintsPerSurface) || (attribs.iHintCount<0) )

 		{

 		return KErrArgument;

 		}	

 	RSurfaceManager::THintPair tempSurfaceHints[KMaxHintsPerSurface];

 	if( (attribs.iHintCount>0) && attribs.iSurfaceHints)

 		{

 		kumemget(tempSurfaceHints, attribs.iSurfaceHints, attribs.iHintCount*sizeof(RSurfaceManager::THintPair));		

 		attribs.iSurfaceHints = tempSurfaceHints;

 		}

 	else

 		{

 		attribs.iSurfaceHints=NULL;

 		}

 	//validate input parameters and calc size

 	TInt roundedBufferSize = attribs.iOffsetBetweenBuffers;

 	TUint actualBufferSize = 0;

 	TInt chunkSize = ValidateAndCalculateChunkSize(attribs, roundedBufferSize, actualBufferSize);

 	if (chunkSize == 0)

 		{

 		return KErrArgument;

 		}

 	NKern::ThreadEnterCS();

 	//Open an existing shared chunk

 	DChunk* chunk = Kern::OpenSharedChunk(NULL, aChunkHandle, EFalse);

 	if(chunk == NULL)

 		{

 		NKern::ThreadLeaveCS();

 		return KErrBadHandle;

 		}

 	//Check for chunk type as kernel multiple

 	if(chunk->iChunkType != ESharedKernelMultiple)

 		{

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		return KErrBadHandle;

 		}

 	//Check for enough chunk size to create surface for requested attributes

 	if (chunk->iSize < attribs.iOffsetToFirstBuffer + attribs.iBuffers * actualBufferSize)

 		{

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	TSurfaceId sid;

 	TSurface* surface = NULL;

 	do		//in the unlikely event that we generate a duplicate surface id, try again.

 		{

 		GenerateSurfaceId(sid);

 		NKern::FMWait(&iMutex);

 		surface = FindSurfaceById(sid);

 		NKern::FMSignal(&iMutex);

 		}

 	while (surface);

 	//create a surface structure for the new surface

 	surface = new TSurface;

 	TRACE(Kern::Printf("SM A %08x TSurface CreateSurface",surface);)

 	if (!surface)

 		{

 		//destroy the chunk and cleanup, out of memory

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		return KErrNoMemory;

 		}

 	TUint32 mapAttr = 0;

 	TBool isContiguous;

 	TInt r = ValidatePhysicalMemory(chunk, attribs, actualBufferSize, mapAttr, isContiguous);

 	if (r != KErrNone)

 		{

 		//destroy the surface and close the chunk

 		delete(surface);

 		Kern::ChunkClose(chunk);

 		NKern::ThreadLeaveCS();

 		if (r != KErrNoMemory)

 			{

 			r = KErrArgument;

 			}

 		return r;

 		}

 	surface->iId = sid;

 	surface->iSize = attribs.iSize;

 	surface->iBuffers = attribs.iBuffers;

 	surface->iPixelFormat = attribs.iPixelFormat;

 	surface->iStride = attribs.iStride;

 	surface->iOffsetToFirstBuffer = attribs.iOffsetToFirstBuffer;

 	surface->iAlignment = attribs.iAlignment;

 	surface->iContiguous = isContiguous;

 	surface->iChunk = chunk;

 	surface->iOffsetBetweenBuffers = (attribs.iOffsetBetweenBuffers) ? attribs.iOffsetBetweenBuffers : roundedBufferSize;

 	surface->iMappable = attribs.iMappable;

 #ifndef __WINS__	//Creation attribute field will not considered for iCacheAttrib

 	TUint32 level1Info = mapAttr & EMapAttrL1CacheMask;

 	TUint32 level2Info = mapAttr & EMapAttrL2CacheMask;

 	TBool chunkIsNotcached =  ((level2Info == EMapAttrL2Uncached) && 

 	    ((level1Info == EMapAttrFullyBlocking) || (level1Info == EMapAttrBufferedNC) ||

 	     (level1Info == EMapAttrBufferedC) || (level1Info == EMapAttrL1Uncached)));

 	surface->iCacheAttrib = (chunkIsNotcached) ? RSurfaceManager::ENotCached : RSurfaceManager::ECached;

 #else

 	surface->iCacheAttrib = RSurfaceManager::ENotCached;	

 #endif

 	if(attribs.iHintCount>0)

 		{

 		memcpy(surface->iSurfaceHints,tempSurfaceHints,attribs.iHintCount*sizeof(RSurfaceManager::THintPair));

 		}

 	memclr(surface->iSurfaceHints+attribs.iHintCount, (KMaxHintsPerSurface-attribs.iHintCount)*sizeof(RSurfaceManager::THintPair));

 	//create a surface owner for this surface

 	TProcessListItem* owner = new TProcessListItem;

 	TRACE(Kern::Printf("SM A %08x TProcessListItem CreateSurface",owner);)

 	if (!owner)

 		{

 		//destroy the chunk and cleanup, out of memory

 		Kern::ChunkClose(chunk);

 		delete(surface);

 		TRACE(Kern::Printf("SM D %08x TSurface CreateSurface",surface);)

 		NKern::ThreadLeaveCS();

 		return KErrNoMemory;

 		}

 	owner->iCount = 1;		//mark it as open in this process

 	owner->iOwningProcess =  &Kern::CurrentProcess();

 	owner->iNext = NULL;

 	surface->iOwners = owner;	//only 1 owner at creation time

 	NKern::FMWait(&iMutex);

 	//at this point we have a fully constructed TSurface

 	//add surface to head of surfaces list

 	//Mask off the bottom log2(KMaxLists) bits of the first word of the surfaceID as an index

 	//add the new surface to the beginning of the list 

 	TInt index = SurfaceIdToIndex(sid);

 	surface->iNext = iSurfacesIndex[index];

 	iSurfacesIndex[index] = surface;

 	NKern::FMSignal(&iMutex);		

 	NKern::ThreadLeaveCS();

 	//write surface id back to user side

 	kumemput(reinterpret_cast<TSurfaceId*>(param.iSurfaceId), &sid, sizeof (TSurfaceId));

 	return KErrNone;

 	}

 /**

 Opens a surface.  If the current process already is in the owners list, its usage count is

 incremented.  If this is an open from a different process, a new surface owner object is added

 to the surface's list of owners and its usage count is set to 1.

 @param aId  The surface id of the surface to be opened.

 @return KErrNone if successful, otherwise a system error code

 @internalTechnology

 */

 TInt DSurfaceManager::OpenSurface(const TSurfaceId* aId)

 	{

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, aId, sizeof (TSurfaceId));

 	NKern::ThreadEnterCS();

 	TProcessListItem* owner = new TProcessListItem;  //speculative creation

 	TRACE(Kern::Printf("SM A %08x TProcessListItem OpenSurface", owner);)

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		delete owner;		//free the memory just allocated

 		TRACE(Kern::Printf("SM D %08x TProcessListItem OpenSurface", owner);)

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (so)

 		{

 		//already an owner so inc the ref count

 		++so->iCount;

 		}

 	else

 		{

 		//new process trying to open it

 		if (!owner)

 			{

 			//the creation of the owner information object failed, out of memory

 			NKern::FMSignal(&iMutex);

 			NKern::ThreadLeaveCS();

 			return KErrNoMemory;

 			}

 		owner->iCount = 1;		//mark it open in this process

 		owner->iOwningProcess =  &Kern::CurrentProcess();

 		//add the owner to the list of owners

 		owner->iNext = surface->iOwners;

 		surface->iOwners = owner;

 		owner = NULL;

 		}

 	NKern::FMSignal(&iMutex);

 	delete owner;		//free if not used.

 	TRACE(Kern::Printf("SM D %08x TProcessListItem OpenSurface", owner);)

 	NKern::ThreadLeaveCS();

 	return KErrNone;

 	}

 /**

 Closes a surface.  Decrements the usage count in the surface owner object

 if the usage count is then zero, removes this surface owner from the surface.

 If this results in a surface with no owners, the surface is deleted and the 

 surface shared chunk is closed.

 @param aId  The id of the surface to be closed

 @return KErrNone if successful, KErrArgument if the surface ID does not refer to a surface,

 KErrAccessDenied if the surface is not open in the current process, otherwise a system wide

 error code.

 @internalTechnology

 */

 TInt DSurfaceManager::CloseSurface(const TSurfaceId* aId)

 	{

 	TSurfaceId sid;

 	kumemget(&sid, aId, sizeof (TSurfaceId));	//fetch surface id from user memory

 	//look it up

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;

 		}

 	//current process is a surface owner so decrement the open count

 	TSurface* surfaceToDelete = NULL;

 	TProcessListItem* ownerToDelete = NULL;

 	DChunk* chunkToClose = NULL;

 	if (--so->iCount == 0)

 		{

 		//if count is now zero remove the owner

 		//surface->RemoveOwner(so);

 		UnlinkListItem(&surface->iOwners, so);

 		ownerToDelete = so;

 		//check to see if the surface has any owners

 		if (!surface->iOwners)

 			{

 			//no more owners of the surface

 			chunkToClose = surface->iChunk;

 			//remove the surface from the list

 			UnlinkListItem(&(iSurfacesIndex[SurfaceIdToIndex(surface->iId)]), surface);

 			surfaceToDelete = surface;

 			}

 		}

 	NKern::FMSignal(&iMutex);

 	if (chunkToClose)

 		{

 		//surface has no more owners so close the chunk

 		Kern::ChunkClose(chunkToClose);

 		}

 	delete surfaceToDelete;

 	TRACE(Kern::Printf("SM D %08x TSurface CloseSurface",surfaceToDelete);)

 	delete ownerToDelete;

 	TRACE(Kern::Printf("SM D %08x TProcessListItem CloseSurface",ownerToDelete);)

 	NKern::ThreadLeaveCS();

 	return KErrNone;

 	}

 /**

 Maps the surface memory into the process of the calling thread. This will fail if

 the surface is not open in this process, or if the handle to the chunk cannot be created.

 @param aId  The id of the surface to be mapped in.

 @return KErrNone if successful, KErrArgument if the surface ID does not refer to a

 surface, KErrAccessDenied if the surface is not open in the current process,

 KErrNotSupported if the surface is not mappable, KErrOverflow if the chunk limit has been

 exceeded in the moving memory model, otherwise a system wide error code.

 @internalTechnology

 */

 TInt DSurfaceManager::MapSurface(const TSurfaceId* aId)

 	{

 	TSurfaceId sid;

 	kumemget(&sid, aId, sizeof (TSurfaceId));	//fetch surface id from user memory

 	//look it up

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;	//surface id is not valid or in the list of surfaces

 		}

 	if(!surface->iMappable)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();		

 		return KErrNotSupported;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;	//can't map it in, it's not open in this process

 		}

 	DChunk* chunk = surface->iChunk;

 	TInt r = chunk->Open();

 	NKern::FMSignal(&iMutex);

 	TRACE(Kern::Printf("SM MapSurface chunk open r %d\n",r);)

 	if (r == KErrGeneral)

 		{

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;

 		}

 	//if we are here, got the surface and we are the owner.

 	//if we are the owner we must have it open at least once

 	r = Kern::MakeHandleAndOpen(NULL, chunk);

 	chunk->Close(NULL);

 	TRACE(Kern::Printf("SM MapSurface handle open r: %d\n",r);)

 	NKern::ThreadLeaveCS();

 	return r;

 	}

 /**

 Record a new connection to the driver.

 Adds an element to the reference counted list of connected processes if the connection

 is from a new process, otherwise it increments the reference count.

 @param aProcess  The process which has opened a driver channel.

 @internalTechnology

 */

 TInt DSurfaceManager::AddConnection(const DProcess* aProcess)

 	{

 	TRACE(Kern::Printf("SM AddConnection process %08x\n", aProcess);)

 	NKern::ThreadEnterCS();

 	TProcessListItem* connectedProcess = new TProcessListItem;  //speculative creation

 	TRACE(Kern::Printf("SM A %08x TProcessListItem AddConnection", connectedProcess);)

 	NKern::FMWait(&iMutex);

 	TProcessListItem* p = FindConnectedProcess(aProcess);

 	if (p)	//already connected, found the process

 		{

 		++p->iCount;

 		}

 	else

 		{

 		//add a new connected process

 		if (!connectedProcess)

 			{

 			//the creation of the owner information object failed, out of memory

 			NKern::FMSignal(&iMutex);

 			NKern::ThreadLeaveCS();

 			return KErrNoMemory;

 			}

 		connectedProcess->iOwningProcess = (DProcess*)aProcess;

 		connectedProcess->iCount=1;

 		connectedProcess->iNext = iConnectedProcesses;

 		iConnectedProcesses = connectedProcess;

 		connectedProcess = NULL;

 		}

 	NKern::FMSignal(&iMutex);

 	delete connectedProcess;

 	TRACE(Kern::Printf("SM D %08x TProcessListItem AddConnection", connectedProcess);)

 	NKern::ThreadLeaveCS();

 	return KErrNone;

 	}

 /**

 Called when the driver channel is closed.

 Decrements the reference count for the connected process, if the last connection

 for this process is closed (reference count reaches 0) it removes the process from the list.

 @param aProcess  The process which has closed the driver channel.

 @internalTechnology

 */

 void DSurfaceManager::RemoveConnection(const DProcess* aProcess)

 	{

 	TRACE(Kern::Printf("SM RemoveConnection process %08x\n", aProcess);)

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	TProcessListItem* p =FindConnectedProcess(aProcess);

 	TProcessListItem* toDelete = NULL;

 	if (p)	//already connected, found the process

 		{

 		if (--p->iCount == 0) //last connection in process has disconnected

 			{

 			//remove the process from the list and cleanup

 			UnlinkListItem(&iConnectedProcesses, p);

 			toDelete = p;

 			}

 		}

 	NKern::FMSignal(&iMutex);

 	delete toDelete;

 	TRACE(Kern::Printf("SM D %08x TProcessListItem RemoveConnection ", toDelete);)

 	if (toDelete)	// if a process has closed its last channel, remove process from the surface owners.

 		{

 		CloseSurfaceHandlesForProcess(aProcess);

 		}

 	NKern::ThreadLeaveCS();

 	}

 /**

 Closes all the surfaces belonging to the process which has just terminated.

 If this is the only owner of a surface, delete the surface.

 @param aProcess  The process which has terminated.

 @pre must be called in critical section

 @internalTechnology

 */

 void DSurfaceManager::CloseSurfaceHandlesForProcess(const DProcess* aProcess)

 	{

 	NKern::FMWait(&iMutex);

 	TSurface* p = NULL;

 	TSurface* surfacesTodelete = NULL;

 	TProcessListItem* ownersTodelete = NULL;

 	TProcessListItem* so;

 	// There are 16 doubly linked lists managed by Surface Manager

 	for (TInt index = 0; index < KMaxLists; index++)

 		{

 		p = iSurfacesIndex[index];

 		while(p)

 			{

 			//see if the process which has just died is an owner of any surfaces

 			TSurface* surface = p;

 			p=p->iNext;

 			so = surface->ProcessOwnerInfo(aProcess);

 			if (so)

 				{

 				UnlinkListItem(&surface->iOwners, so);

 				so->iNext = ownersTodelete;	//add the owner to the list of owner objects to remove

 				ownersTodelete = so;

 				if (!surface->iOwners)	//if the surface hasn't any owners

 					{

 					//remove the surface from the list

 					UnlinkListItem(&iSurfacesIndex[index], surface);

 					surface->iNext = surfacesTodelete;	//add the surface to the list of surfaces to remove

 					surfacesTodelete = surface;

 					}

 				}

 			}

 		}

 	NKern::FMSignal(&iMutex);

 	while(surfacesTodelete)

 		{

 		p = surfacesTodelete->iNext;

 		Kern::ChunkClose(surfacesTodelete->iChunk);

 		TRACE(Kern::Printf("SM Close chunk %08x CloseSurfaceHandlesForProcess",surfacesTodelete->iChunk);)

 		delete surfacesTodelete;

 		TRACE(Kern::Printf("SM D %08x TSurface CloseSurfaceHandlesForProcess",surfacesTodelete);)

 		surfacesTodelete = p;

 		}

 	while(ownersTodelete)

 		{

 		so = ownersTodelete->iNext;

 		delete ownersTodelete;

 		TRACE(Kern::Printf("SM D %08x TProcessListItem CloseSurfaceHandlesForProcess",ownersTodelete);)

 		ownersTodelete = so;

 		}

 	}

 /**

 Returns the metadata information about the specified surface.

 @param aId  The id of the surface.

 @param aInfo  Pointer to user side descriptor to receive the information.

 @return KErrNone if successful, KErrArgument if the surface ID does not refer to a surface,

 KErrAccessDenied if the surface is not open in the current process, otherwise a system wide

 error code.

 @internalTechnology

 */	

 TInt DSurfaceManager::SurfaceInfo(const TSurfaceId* aId, TDes8* aInfo)

 	{

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, aId, sizeof (TSurfaceId));

 	RSurfaceManager::TInfoBuf buf;

 	RSurfaceManager::TSurfaceInfoV01& info = buf();

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrAccessDenied;	//can do this, not open

 		}

 	//at this point, we have a surface, we are the owner and it's mapped in

 	info.iSize = surface->iSize; 									// Visible width/height in pixels

 	info.iBuffers = surface->iBuffers;								// Number of Buffers

 	info.iPixelFormat = surface->iPixelFormat;	      				// pixel format

 	info.iStride = surface->iStride;								// Number of bytes between start of one line and start of next

 	info.iContiguous = surface->iContiguous;						// is it physically contiguous

 	info.iCacheAttrib = surface->iCacheAttrib;						// Underlying chunk is CPU cached or not

 	info.iMappable = surface->iMappable;							// Is the surface Mappable

 	NKern::FMSignal(&iMutex);

 	//copy it back to user side

 	Kern::InfoCopy(*aInfo, buf);

 	return KErrNone;

 	}

 /**

 Generates a unique surface id

 @param aId  Surface id reference to receive the generated id.

 @internalTechnology

 */	

 void DSurfaceManager::GenerateSurfaceId(TSurfaceId& aId)

 	{

 	TSurfaceId id;

 	for (TInt x = 0; x < 4; ++x)

 		{

 		id.iInternal[x] = Kern::Random();

 		};

 	//package up the handle,

 	//set the type identifier

 	id.iInternal[3] &= 0x00FFFFFF;

 	id.iInternal[3] |= TSurfaceTypes::ESurfaceManagerSurface << 24;

 	aId = id;

 	TRACE(Kern::Printf("SM GenerateSurfaceId id = %u %u %u %u\n",id.iInternal[0],id.iInternal[1],id.iInternal[2],id.iInternal[3]);)

 	};

 /**

 Validates the surface creation attributes and calculates the size of the chunk required.

 @param aAttribs  The surface creation attributes used to specify the surface requirements.

 @param aOffset  Set to the offset between buffers on successfull return.

 @param aNewChunk  If this is true, surface is created in a new chunk otherwise the surface is created in an existing chunk

 @return The size of chunk required.  A size of 0 indicates a problem.

 */	

 TInt DSurfaceManager::ValidateAndCalculateChunkSize(RSurfaceManager::TSurfaceCreationAttributes& aAttribs, 

 			TInt& aOffset, TUint &aActualBufferSize, const TBool aNewChunk)

 	{

 /*	

 	TRACE(Kern::Printf("SM width = %d  height = %d\n", aAttribs.iSize.iWidth, aAttribs.iSize.iHeight);)

 	TRACE(Kern::Printf("SM buffers = %d\n", aAttribs.iBuffers);)

 	TRACE(Kern::Printf("SM format = %d\n", aAttribs.iPixelFormat);)

 	TRACE(Kern::Printf("SM stride = %d\n", aAttribs.iStride);)

 	TRACE(Kern::Printf("SM offset to first buffer = %d\n", aAttribs.iOffsetToFirstBuffer);)

 	TRACE(Kern::Printf("SM offset between buffer = %d\n", aOffset);)

 	TRACE(Kern::Printf("SM alignment = %d\n", aAttribs.iAlignment);)

 	TRACE(Kern::Printf("SM contiguous = %d\n\n", aAttribs.iContiguous);)

 	TRACE(Kern::Printf("SM cacheAttrib = %d\n\n", aAttribs.iCacheAttrib);)

 */

 	//check for negative values

 	if(aAttribs.iOffsetToFirstBuffer < 0 || aOffset < 0 )

 		{

 		TRACE(Kern::Printf("SM Validate offset for negative value");)

 		return 0;

 		}

 	//check aligment is sensible

 	TInt alignmentMask = 0;

 	switch(aAttribs.iAlignment)

 		{

 		case 1:	

 		case 2:	

 		case 4: 

 		case 8: 

 		case 16: 

 		case 32: 

 			alignmentMask = 31; 

 			break;

 		case 64: 

 			alignmentMask = 63; 

 			break;

 		case RSurfaceManager::EPageAligned:

 			break;

 		default:

 			TRACE(Kern::Printf("SM Validate alignment");)

 			return 0;

 		}

 	//check alignment issues.

 	if(aAttribs.iAlignment != RSurfaceManager::EPageAligned)

 		{

 		if(aNewChunk)	

 			{

 			if(aAttribs.iCacheAttrib == RSurfaceManager::ECached)	// Surface is CPU cached, so the alignment will be based on either 32 or 64 byte 

 				{

 				//offset to first buffer needs to fit alignment

 				aAttribs.iOffsetToFirstBuffer = aAttribs.iOffsetToFirstBuffer + alignmentMask & ~alignmentMask;

 				//alignment with respect to offsetbetweenbuffers

 				aOffset = aOffset + alignmentMask & ~alignmentMask;

 				}

 			else	// Surface is NOT CPU cached, so the alignment will be based on surface attribute alignment

 				{

 				TUint alignMask = aAttribs.iAlignment-1;

 				//offset to first buffer needs to fit alignment

 				aAttribs.iOffsetToFirstBuffer = aAttribs.iOffsetToFirstBuffer + alignMask & ~alignMask;

 				//alignment with respect to offsetbetweenbuffers

 				aOffset = aOffset + alignMask & ~alignMask;

 				}

 			}

 		else	// existing chunk

 			{

 			TUint alignMask = aAttribs.iAlignment-1;

 			//check alignment issues.  offset to first buffer needs to fit alignment

 			if (aAttribs.iOffsetToFirstBuffer & alignMask)

 				{

 				TRACE(Kern::Printf("SM Validate offset to first pixel misaligned");)

 				return 0;

 				}

 			//check alignment for offsetbetweenbuffers.  offset between buffer needs to fit alignment for existing chunks

 			if (aOffset & alignMask)

 				{

 				TRACE(Kern::Printf("SM Validate offset between buffers misaligned");)

 				return 0;

 				}

 			}

 		}

 	else	//page aligned

 		{

 		if(aNewChunk)// if its a new chunks and doesn't match exact alignment then do the rounding

 			{

 			TUint32 pageSize = Kern::RoundToPageSize(1);

 			//offset to first buffer needs to fit alignment

 			aAttribs.iOffsetToFirstBuffer = (aAttribs.iOffsetToFirstBuffer + (pageSize - 1)) & ~(pageSize - 1);

 			//alignment with respect to offsetbetweenbuffers

 			aOffset = (aOffset + (pageSize - 1)) & ~((pageSize - 1));

 			}

 		else	// for existing chunks don't do any rounding operation

 			{

 			TUint32 pageSize = Kern::RoundToPageSize(1);

 			TUint alignmask = aAttribs.iOffsetToFirstBuffer & (pageSize - 1);

 			if (alignmask)

 				{

 				TRACE(Kern::Printf("SM Validate offset to first pixel misaligned");)

 				return 0;

 				}

 			alignmask = aOffset & (pageSize - 1);

 			if (alignmask)

 				{

 				TRACE(Kern::Printf("SM Validate offset between buffers misaligned");)

 				return 0;

 				}

 			}

 		}

 	//check width and height

 	if(aAttribs.iSize.iWidth <= 0 || aAttribs.iSize.iHeight <= 0)

 		{

 		TRACE(Kern::Printf("SM Validate width/height");)

 		return 0;

 		}

 	//check there is at least 1 buffer

 	if (aAttribs.iBuffers <= 0)

 		{

 		TRACE(Kern::Printf("SM Validate buffers");)

 		return 0;

 		}

 	//Sort the array and also check for duplication

 	if (!SortHints(aAttribs.iSurfaceHints,aAttribs.iHintCount)) 

 		{

 		TRACE(Kern::Printf("SM Validate Duplicate hint key");)

 		return 0;

 		}

 	TUint size = 0;

 	//calculate buffer size and round it to alignment or to page size

 	TInt64 bufferSize = aAttribs.iStride;

 	bufferSize  *= aAttribs.iSize.iHeight;

 	if (I64HIGH(bufferSize) > 0) //too big

 		{

 		TRACE(Kern::Printf("SM Validate chunk buffer size is out of range");)

 		return 0;

 		}

 	TUint bsize = I64LOW(bufferSize);

 	if (bsize > KMaxTInt)

 		{

 		TRACE(Kern::Printf("SM Validate buffer size is out of range for TInt");)

 		return 0;

 		}

 	if(aAttribs.iAlignment == RSurfaceManager::EPageAligned)

 		{

 		bsize = Kern::RoundToPageSize(bsize);	//page alignment

 		}

 	else if(aAttribs.iCacheAttrib == RSurfaceManager::ECached)

 		{

 		bsize = bsize + alignmentMask & ~alignmentMask;	//CPU cached byte alignment, for minimum of the specified alignment(32 or 64)

 		}

 	else

 		{

 		bsize = bsize + (aAttribs.iAlignment-1) & ~(aAttribs.iAlignment-1);	//NON CPU cached byte alignment for 1, 2, 4, 8, 16, 32 and 64

 		}

 	bufferSize = bsize;

 	// Remember the actual size. 

 	aActualBufferSize = bsize;

 	//if offset between buffers is zero, then assign the calculated value as offset between buffers

 	if(aOffset == 0)

 		{

 		//buffer size rounded to alignment as offset between buffers

 		aOffset = I64INT(bufferSize);

 		}

 	else if(aOffset < I64INT(bufferSize))

 		{

 		TRACE(Kern::Printf("SM Offset between the buffer is less than the required size");)

 		return 0;

 		}

 	else

 		{

 		//use the buffer size specified

 		bufferSize = aOffset;

 		}

 	TInt64 totalSize = aAttribs.iOffsetToFirstBuffer + (aAttribs.iBuffers * bufferSize);

 	if (I64HIGH(totalSize) > 0) //too big

 		{

 		TRACE(Kern::Printf("SM Validate chunk size is out of range for RoundToPageSize");)

 		return 0;

 		}

 	size = I64LOW(totalSize);

 	if (size > KMaxTInt)

 		{

 		TRACE(Kern::Printf("SM Validate size is out of range for TInt");)

 		return 0;

 		}

 	size = Kern::RoundToPageSize(size);

 	//check the size isn't greater than will fit in a TInt

 	if (size > KMaxTInt)

 		{

 		TRACE(Kern::Printf("SM Rounded size is out of range for TInt");)

 		return 0;

 		}

 	TRACE(Kern::Printf("SM After validate - offset to first buffer = %d\n", aAttribs.iOffsetToFirstBuffer);)

 	TRACE(Kern::Printf("SM After validate - offset between buffer = %d\n", aOffset);)

 	TRACE(Kern::Printf("SM CalculateChunkSize size = %d\n", size);)

 	return size;

 	}

 /**

 Find the surface in the list.   

 @param aId  The surface id of the surface to find in the surface list

 @return pointer to the surface object

 @internalTechnology

 */

 TSurface* DSurfaceManager::FindSurfaceById(const TSurfaceId& aId)

 	{

 	TSurface *p = iSurfacesIndex[SurfaceIdToIndex(aId)];

 	while (p)

 		{

 		if (aId == p->iId)

 			{

 			//found it

 			return p;

 			}

 		p = p->iNext;

 		}

 	return NULL;

 	}

 /**

 Find the index of the hint key from the surface list using binary search.   

 @param aHintsArray  Pointer to the first element in the array of surface hints

 @param aKey  The surface hint key uid value to search in the surface list

 @return index of the hint pair key in the surface list, KErrNotFound if key not found

 @internalTechnology

 */

 TInt DSurfaceManager::FindHintKey(const RSurfaceManager::THintPair* aHintsArray, TUint32 aKey) const

 	{

 	__ASSERT_DEBUG(aHintsArray != NULL, Kern::Fault("Surface Manager", __LINE__));

 	TInt bottom = 0;

 	TInt top = KMaxHintsPerSurface - 1;

 	TInt mid;

 	while (bottom <= top)

 		{

 	    mid = (bottom + top) / 2;

 	    if((TUint) aHintsArray[mid].iKey.iUid == aKey)

 	    	{

 	    	return mid;

 	    	} 

 	    else if ((TUint)aHintsArray[mid].iKey.iUid < aKey) 

 	    	{

 	    	top = mid - 1;

 	    	}

 	    else

 	    	{

 	    	bottom = mid + 1;

 	    	}

 	  }

 	return KErrNotFound;	//Hint key not found

     }

 TProcessListItem* DSurfaceManager::FindConnectedProcess(const DProcess* aProcess)

 	{

 	TProcessListItem * p = iConnectedProcesses;

 	while (p)

 		{

 		if (aProcess == p->iOwningProcess)

 			{

 			//found it

 			return p;

 			}

 		p = p->iNext;

 		}

 	return NULL;

 	}

 /**

 Searches for a right place to insert the new hint pair in a sorted array.

 @param aHintsArray  Pointer to the first element in the sorted array

 @param aKey  The surface hint key uid value to search in the surface list

 @pre, there is at least one empty place in the array

 @return KErrNone if a new hint pair key inserted in the surface list, KErrAlreadyExists if duplicated

 @internalTechnology

 */

 TInt DSurfaceManager::InsertHintKey(RSurfaceManager::THintPair* aHintsArray, const RSurfaceManager::THintPair& aHintPair) const

 	{

 	__ASSERT_DEBUG(aHintsArray != NULL, Kern::Fault("Surface Manager", __LINE__));

 	__ASSERT_DEBUG(aHintsArray[KMaxHintsPerSurface-1].iKey.iUid == NULL, Kern::Fault("Surface Manager", __LINE__));

 	TInt pos = 0;

 	if (aHintsArray[pos].iKey.iUid != 0)

 		{

 		while((TUint)aHintsArray[pos].iKey.iUid>(TUint)aHintPair.iKey.iUid && pos < KMaxHintsPerSurface-1)

 			{// find the right place to insert

 			++pos;

 			}

 		if((TUint)aHintsArray[pos].iKey.iUid==(TUint)aHintPair.iKey.iUid)

 			{

 			//Duplicate key 

 			return KErrAlreadyExists;

 			}

 		else

 			{

 			// Shift right

 			memmove(aHintsArray+pos+1, aHintsArray+pos, (KMaxHintsPerSurface-pos-1)*sizeof(RSurfaceManager::THintPair));		

 			}	

 		}

 	aHintsArray[pos] = aHintPair;

 	return KErrNone;

 	}

 /**

 Sort the surface hint array in descending order.

 @param aHintsArray  The surface hintpair in the surface list

 @param aNumberOfHints The number of hints

 @return ETrue if sorting is finished or it is an empty array, EFalse if key duplicated

 @internalTechnology

 */

 TBool DSurfaceManager::SortHints(RSurfaceManager::THintPair* aHintsArray, TInt aNumberOfHints) const

 	{

 	TInt in = 0;

 	TInt out = 0;

 	RSurfaceManager::THintPair temp;

 	if(!aHintsArray)

 		{

 		return ETrue;

 		}

 	for(out = 0; out < aNumberOfHints; ++out) 

 		{

 		if(aHintsArray[out].iKey.iUid != 0)

 			{

 			temp = aHintsArray[out];   

 			in = out;          // start shifting at out

 			while(in > 0 && (TUint)aHintsArray[in-1].iKey.iUid <= (TUint)temp.iKey.iUid)

 				{

 				if ((TUint)aHintsArray[in-1].iKey.iUid == (TUint)temp.iKey.iUid)

 					{

 					return EFalse;		//duplicate hint keys are not allowed

 					}

 				aHintsArray[in] = aHintsArray[in-1];     // shift item to the right

 				--in;          // go left one position

 				}

 			aHintsArray[in] = temp;        // insert marked item

 			}

 		}

 	return ETrue;

 	}

 /**

 Ensures the memory is updated consistently before/after triggering non CPU hardware access. 

 @param aParam  The suface id and buffer number (0 based).

 @param aOperation  The type of the synchronize operation. 

 @return KErrNone if successful, KErrArgument if the surface ID is invalid or

 buffer number is invalid, KErrAccessDenied if the surface is not open in this

 process, otherwise a system wide error code.

 @see RSurfaceManager::TSyncOperation

 @internalTechnology

 */	

 TInt DSurfaceManager::SynchronizeCache(RSurfaceManagerDriver::TDeviceParam* aParam, RSurfaceManager::TSyncOperation aOperation)

 	{

 	//Parse the parameters

 	RSurfaceManagerDriver::TDeviceParam param;

 	kumemget(&param, aParam, sizeof(RSurfaceManagerDriver::TDeviceParam));

 	TSurfaceId sid;

 	kumemget(&sid, param.iSurfaceId, sizeof(TSurfaceId));

 	TInt buffer = (TInt)param.iBuffer;

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;

 		}

 	// surfaces have to have at least one buffer

 	__ASSERT_DEBUG(surface->iBuffers > 0, Kern::Fault("Surface Manager", __LINE__));

 	//Validate the buffer number is within range

 	if((buffer >= surface->iBuffers) || (buffer < 0))

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	DChunk* chunk = surface->iChunk;

 	TInt offsetBetweenBuffers = surface->iOffsetBetweenBuffers;

 	NKern::FMSignal(&iMutex);

 	TUint32 kernAddr;

 	TUint32 mapAttr;

 	TUint32 physAddr;

 	TInt pageList = chunk->iSize / Kern::RoundToPageSize(1) + 1;

 	TUint32* physAddr2 = new TUint32[pageList];

 	if(!physAddr2)

 		{

 		NKern::ThreadLeaveCS();

 		return KErrNoMemory;

 		}

 	TRACE(Kern::Printf("SM %08x DChunk SynchronizeCache", chunk);)

 	//Retrieve the kernel address and mapping attribute from the chunk

 	TInt err = Kern::ChunkPhysicalAddress(chunk, surface->iOffsetToFirstBuffer + (buffer * offsetBetweenBuffers), offsetBetweenBuffers, kernAddr, mapAttr, physAddr, physAddr2);

 	delete[] physAddr2;

 	if(err >= KErrNone)

 		{

 		TRACE(Kern::Printf("SM %08x kernAddr SynchronizeCache", kernAddr);)

 		TRACE(Kern::Printf("SM %08x mapAttr SynchronizeCache", mapAttr);)

 		err = KErrNone;

 		// Do the sync operation

 		switch(aOperation)

 			{

 			case RSurfaceManager::ESyncBeforeNonCPURead:

 				Cache::SyncMemoryBeforeDmaWrite(kernAddr, offsetBetweenBuffers, mapAttr);

 				break;

 			case RSurfaceManager::ESyncBeforeNonCPUWrite:

 				Cache::SyncMemoryBeforeDmaRead(kernAddr, offsetBetweenBuffers, mapAttr);

 				break;

 			case RSurfaceManager::ESyncAfterNonCPUWrite:

 				Cache::SyncMemoryAfterDmaRead(kernAddr, offsetBetweenBuffers);

 				break;

 			default: 

 				err = KErrArgument;

 				break;

 			}			

 		}

 	NKern::ThreadLeaveCS();

 	return err;

 	}

 /**

 Get the surface hint value for the given surface ID and hint pair key.

 @param aSurfaceId  The surface identifier originally returned when the surface was created.

 @param aHintPair  The hint value for the requested hint pair key.

 @return KErrNone if successful, KErrArgument if the surface ID is invalid or

 invalid hint pair key used, KErrAccessDenied if the surface is not open in the

 current process, otherwise a system wide error code.

 @internalTechnology

 */ 

 TInt DSurfaceManager::GetSurfaceHint(const TSurfaceId* aSurfaceId, RSurfaceManager::THintPair* aHintPair)

 	{

 	RSurfaceManager::THintPair hintPair;

 	kumemget(&hintPair, aHintPair, sizeof(RSurfaceManager::THintPair));

 	if (hintPair.iKey.iUid == 0)

 		{

 		TRACE(Kern::Printf("SM GetSurfaceHint Hint key is invalid");)

 		return KErrArgument;	//Invalid Hint key

 		}

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, aSurfaceId, sizeof (TSurfaceId));

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrAccessDenied;

 		}

 	//at this point, we have a surface, we have to find the hint value based on the hint pair key

 	TInt index = FindHintKey(surface->iSurfaceHints, hintPair.iKey.iUid);

 	if (index == KErrNotFound)

 		{

 		TRACE(Kern::Printf("SM GetSurfaceHint Hint key not found");)

 		NKern::FMSignal(&iMutex);

 		return KErrArgument;	//Hint key not found

 		}

 	RSurfaceManager::THintPair hint = surface->iSurfaceHints[index];

 	NKern::FMSignal(&iMutex);

 	TRACE(Kern::Printf("SM GetSurfaceHint Hint value %d", hint.iValue);)

 	//write it back to user side

 	kumemput(aHintPair, &hint, sizeof(RSurfaceManager::THintPair));

 	return KErrNone;

 	}

 /**

 Set the surface hint value for an existing surface hint key of the surface Id.

 @param aSurfaceId  The surface identifier originally returned when the surface was created.

 @param aHintPair  The value of the hint pair to set.

 @return KErrNone if successful, KErrArgument if the surface ID is invalid or if invalid

 hint key used, KErrAccessDenied if the hint pair is immutable or the surface is not open

 in the current process, otherwise a system wide error code.

 @internalTechnology

 */ 

 TInt DSurfaceManager::SetSurfaceHint(const TSurfaceId* aSurfaceId, const RSurfaceManager::THintPair* aHintPair)

 	{

 	RSurfaceManager::THintPair hintPair;

 	kumemget(&hintPair, aHintPair, sizeof(RSurfaceManager::THintPair));

 	//Check for valid hint key

 	if (!hintPair.iKey.iUid)

 		{

 		TRACE(Kern::Printf("SM SetSurfaceHint Hint key is invalid");)

 		return KErrArgument;	//Invalid Hint key

 		}

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, aSurfaceId, sizeof (TSurfaceId));

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;

 		}

 	//at this point, we have a surface, we have to find the hint value based on the hint pair key

 	TInt index = FindHintKey(surface->iSurfaceHints, hintPair.iKey.iUid);

 	if (index == KErrNotFound)

 		{

 		TRACE(Kern::Printf("SM SetSurfaceHint Hint key not found or invalid");)

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;	//Hint key not found or invalid

 		}

 	//Check for mutability

 	if(!surface->iSurfaceHints[index].iMutable)

 		{

 		TRACE(Kern::Printf("SM SetSurfaceHint Hint is immutable");)

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;	//Hint pair is immutable

 		}

 	TRACE(Kern::Printf("SM SetSurfaceHint Hint key found and updated its value %d for the surface %08x \n", aHintPair->iValue, &sid);)

 	//set the hint pair value now

 	memcpy(&surface->iSurfaceHints[index], &hintPair, sizeof(RSurfaceManager::THintPair));

 	NKern::FMSignal(&iMutex);

 	NKern::ThreadLeaveCS();

 	return KErrNone;

 	}

 /**

 Add a new surface hint value for the surface Id.

 @param aSurfaceId  The surface identifier originally returned when the surface was created.

 @param aHintPair  The value of the hint pair to Add.

 @return Returns KErrNone if successful, KErrArgument if the surface ID is invalid or the

 hint pair has invalid key UID, KErrAccessDenied if the surface is not open in the current

 process, KErrAlreadyExists if duplicate hint key used, KErrOverflow if no space to add new

 pair, otherwise a system wide error code.

 @internalTechnology

 */ 

 TInt DSurfaceManager::AddSurfaceHint(const TSurfaceId* aSurfaceId, const RSurfaceManager::THintPair* aHintPair)

 	{

 	RSurfaceManager::THintPair hintPair;

 	kumemget(&hintPair, aHintPair, sizeof(RSurfaceManager::THintPair));

 	//Check for valid hint key

 	if (hintPair.iKey.iUid == 0)

 		{

 		TRACE(Kern::Printf("SM AddSurfaceHint Hint key is invalid");)

 		return KErrArgument;	//Invalid Hint key

 		}

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, aSurfaceId, sizeof (TSurfaceId));

 	NKern::ThreadEnterCS();

 	NKern::FMWait(&iMutex);

 	//look it up

 	TSurface* surface = FindSurfaceById(sid);

 	if (!surface)	

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrArgument;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrAccessDenied;

 		}

 	//Check for empty hint pair

 	if(surface->iSurfaceHints[KMaxHintsPerSurface - 1].iKey.iUid != 0)//at least end of sorted hint array should be 0 to add a new hint

 		{

 		TRACE(Kern::Printf("SM AddSurfaceHint there is no room to add the hint");)

 		NKern::FMSignal(&iMutex);

 		NKern::ThreadLeaveCS();

 		return KErrOverflow;	//No room for new hint

 		}

 	//We found room for a new hint pair, so insert it in the array

 	// Meanwhile, we check for duplication, if it is, return KErrAlreadyExists

 	TInt err = InsertHintKey(surface->iSurfaceHints,hintPair);

 	NKern::FMSignal(&iMutex);

 	TRACE(Kern::Printf("SM AddSurfaceHint Added new key ");)

 	NKern::ThreadLeaveCS();

 	return err;

 	}

 /**

 Get the offset of the specified buffer from the base address of the underlying

 chunk.

 To obtain the address of the buffer, the offset returned must be added onto the

 base address of the RChunk returned in a call to MapSurface(). Note that

 buffer offsets are immutable during the lifetime of the surface.

 @param aParam The input parameters including the surface ID and buffer index.

 @pre The surface is open in the calling process.

 @return KErrNone if successful, KErrArgument if aSurfaceId or aBuffer are invalid,

 KErrAccessDenied if the surface is not open in the current process, KErrNotSupported if

 the surface is not mappable, otherwise a system wide error code.

 */

 TInt DSurfaceManager::GetBufferOffset(RSurfaceManagerDriver::TDeviceParam* aParam,TUint* aOffset)

 	{

 	//Get the input parameters

 	RSurfaceManagerDriver::TDeviceParam param;

 	kumemget(&param, aParam, sizeof(RSurfaceManagerDriver::TDeviceParam));

 	TSurfaceId sid;

 	//fetch surface id from user memory

 	kumemget(&sid, param.iSurfaceId, sizeof(TSurfaceId));

 	//(TAny*)iBuffer holds the buffer number in its value

 	TInt bufferNumber = (TInt) param.iBuffer;

 	TSurface* surface = NULL;

 	NKern::FMWait(&iMutex);

 	surface = FindSurfaceById(sid);

 	if(NULL == surface || (bufferNumber >= surface->iBuffers))

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrArgument;

 		}

 	if(!surface->iMappable)

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrNotSupported;

 		}

 	//find the owner

 	TProcessListItem* so = surface->ProcessOwnerInfo(&Kern::CurrentProcess());

 	if (!so)

 		{

 		NKern::FMSignal(&iMutex);

 		return KErrAccessDenied;		

 		}

 	TInt bufferOffset = surface->iOffsetToFirstBuffer + bufferNumber*surface->iOffsetBetweenBuffers;

 	NKern::FMSignal(&iMutex);

 	kumemput(aOffset, &bufferOffset, sizeof (TInt));

 	return KErrNone;

 	}

 /**

 Returns information specific to the Surface Manager implementation.

 @param aAttrib: Attribute to retrieve

 @param aValue : Output parameter where we write the value for the specified attribute

 @return KErrNone if successful or KErrArgument if the attribute UID is not recognized

 @internalTechnology

 */

 TInt DSurfaceManager::GetSurfaceManagerAttrib(RSurfaceManager::TSurfaceManagerAttrib* aAttrib,TInt* aValue)

 	{

 	RSurfaceManager::TSurfaceManagerAttrib attrib;

 	kumemget(&attrib, aAttrib, sizeof(RSurfaceManager::TSurfaceManagerAttrib));

 	TInt out=KErrNone;

 	TInt value;

 	switch (attrib)

 		{

 		case RSurfaceManager::EMaxNumberOfHints:

 			value=KMaxHintsPerSurface;

 			break;		

 		default:

 			out=KErrArgument;

 			break;			

 		};

 	if (out==KErrNone)

 		{

 		kumemput(aValue, &value, sizeof (TInt));

 		}	

 	return out;

 	}