// 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 <kernel/cache.h>

#include <graphics/surface.h>

#include <graphics/surfacetypes.h>

#include <graphics/surfacemanager.h>

#include "surfacemanager_dev.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

#ifdef GRAPHICS_SURFACEMANAGER_SYBORG

	// ChunkCommitPhysical method may only be used if the chunk was

	// created with TChunkCreateInfo::iOwnsMemory set to false.

    info.iMapAttr = EMapAttrFullyBlocking;

    info.iOwnsMemory = EFalse;

#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;

#ifdef GRAPHICS_SURFACEMANAGER_SYBORG 

    Kern::Printf("DSurfaceManager::CreateSurface: Allocate ");

    if( iVHWMemoryManager != NULL )

		{

	    paddr = iVHWMemoryManager->Allocate(chunkSize);

		}

	else

		{

		CreateMemory();

	    paddr = iVHWMemoryManager->Allocate(chunkSize);

		}

    if ( paddr )

        {

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

	    Kern::Printf("DSurfaceManager::CreateSurface: Commit %d from: 0x%08x success: %d",chunkSize, paddr, r );

        }

    else

        {

        r = KErrNoMemory;

        }

#else // GRAPHICS_SURFACEMANAGER_SYBORG

	if (attribs.iContiguous)

		{

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

		}

	else

		{

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

		}

#endif // GRAPHICS_SURFACEMANAGER_SYBORG

	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