// 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: