// Copyright (c) 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:

// Graphics Resource - kernel extension implementation

//

#include <kernel/kern_priv.h>

#include "sgextensionimpl.h"

DSgExtensionImpl* TheSgExtensionImpl = NULL;

DECLARE_STANDARD_EXTENSION()

	{

	__KTRACE_OPT(KBOOT, Kern::Printf("Starting Graphics Extension"));

	TInt err;

	TheSgExtensionImpl = new DSgExtensionImpl;

	if (TheSgExtensionImpl)

		{

		err = TheSgExtensionImpl->Construct();

		if (err != KErrNone)

			{

			delete TheSgExtensionImpl;

			TheSgExtensionImpl = NULL;

			}

		}

	else

		{

		err = KErrNoMemory;

		}

	if (err != KErrNone)

		{

		__KTRACE_OPT(KBOOT, Kern::Printf("Error: Graphics Extension failed to start"));

		}

	return err;

	}

EXPORT_C TVersion SgExtension::Version()

	{

	return TVersion(1, 1, 1);

	}

EXPORT_C TInt SgExtension::CreateResource(TUint32 aAttribs, const TDesC8& aMetaData, TInt aDataSize, DSgResource*& aResource)

	{

	if (!TheSgExtensionImpl)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("Error: Graphics Extension not ready"));

		return KErrNotReady;

		}

	return TheSgExtensionImpl->CreateResource(aAttribs, aMetaData, aDataSize, aResource);

	}

EXPORT_C TInt SgExtension::FindAndOpenResource(TUint64 aId, DSgResource*& aResource)

	{

	if (!TheSgExtensionImpl)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("Error: Graphics Extension not ready"));

		return KErrNotReady;

		}

	return TheSgExtensionImpl->FindAndOpenResource(aId, aResource);

	}

EXPORT_C TInt SgExtension::GlobalResourceCount()

	{

	if (!TheSgExtensionImpl)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("Error: Graphics Extension not ready"));

		return KErrNotReady;

		}

	return TheSgExtensionImpl->GlobalResourceCount();

	}

EXPORT_C TInt SgExtension::GlobalGraphicsMemoryUsed()

	{

	if (!TheSgExtensionImpl)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("Error: Graphics Extension not ready"));

		return KErrNotReady;

		}

	return TheSgExtensionImpl->GlobalGraphicsMemoryUsed();

	}

TInt DSgExtensionImpl::Construct()

	{

	return Kern::MutexCreate(iMutex, KNullDesC8, KMutexOrdGeneral0);

	}

TInt DSgExtensionImpl::CreateResource(TUint32 aAttribs, const TDesC8& aMetaData, TInt aDataSize, DSgResource*& aResource)

	{

	if (aDataSize <= 0)

		{

		return KErrArgument;

		}

	DSgResourceImpl* resource = static_cast<DSgResourceImpl*>(Kern::Alloc(sizeof(DSgResourceImpl) + aMetaData.Size()));

	if (!resource)

		{

		return KErrNoMemory;

		}

    TChunkCreateInfo info;

	info.iType = TChunkCreateInfo::ESharedKernelMultiple;

	info.iMaxSize = aDataSize;

	info.iOwnsMemory = ETrue;

#ifdef __WINS__

	info.iMapAttr = aAttribs, 0; // suppress compiler warning: cache attribute does not apply to WINS

#else

	info.iMapAttr = aAttribs & ESgResourceAttrCpuCached ? EMapAttrCachedMax : EMapAttrL1Uncached;

#endif

	DChunk* chunk;

	TLinAddr kernAddr;

	TUint32 mapAttr;

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

	if (err != KErrNone)

		{

		Kern::Free(resource);

		return err;

		}

	err = Kern::ChunkCommit(chunk, 0, aDataSize);

	if (err != KErrNone)

		{

		Kern::ChunkClose(chunk);

		Kern::Free(resource);

		return err;

		}

	Kern::MutexWait(*iMutex);

	new(resource) DSgResourceImpl(*this, ++iLastResourceId, aAttribs, aMetaData, chunk, aDataSize);

	err = iResources.InsertInOrder(resource, DSgResource::Compare);

	Kern::MutexSignal(*iMutex);

	if (err != KErrNone)

		{

		resource->Close();

		}

	aResource = (err == KErrNone ? resource : NULL);

	return err;

	}

TInt DSgExtensionImpl::FindAndOpenResource(TUint64 aId, DSgResource*& aResource)

	{

	if (aId == 0)

		{

		return KErrArgument;

		}

	Kern::MutexWait(*iMutex);

	TInt i = iResources.FindInOrder(aId, DSgResource::Compare);

	if (i < 0)

		{

		Kern::MutexSignal(*iMutex);

		return KErrNotFound;

		}

	DSgResource* resource = iResources[i];

	TInt err = resource->Open();

	Kern::MutexSignal(*iMutex);

	aResource = (err == KErrNone ? resource : NULL);

	return err;

	}

void DSgExtensionImpl::DeleteResource(DSgResource* aResource)

	{

	Kern::MutexWait(*iMutex);

	TInt i = iResources.FindInOrder(aResource, DSgResource::Compare);

	if (i >= 0)

		{

		iResources.Remove(i);

		}

	else

		{

		__KTRACE_OPT(KPANIC, Kern::Printf("Error: internal state of Graphics Extension is inconsistent"));

		}

	Kern::MutexSignal(*iMutex);

	delete aResource;

	}

TInt DSgExtensionImpl::GlobalResourceCount() const

	{

	return iResources.Count();

	}

TInt DSgExtensionImpl::GlobalGraphicsMemoryUsed() const

	{

	TInt ret = 0;

	Kern::MutexWait(*iMutex);

	TInt n = iResources.Count();

	for (TInt i = 0; i < n; ++i)

		{

		ret += iResources[i]->DataChunk()->Size();

		}

	Kern::MutexSignal(*iMutex);

	return ret;

	}