// 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 - logical channel implementation

//

#include <kernel/kern_priv.h>

#include <sgresource/sgextension.h>

#include "sgdeviceimpl.h"

TInt DSgChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVersion)

	{

	TVersion version = SgExtension::Version();

	if (aVersion.iMajor != version.iMajor || aVersion.iMinor > version.iMinor)

		{

		return KErrNotSupported;

		}

	return Kern::MutexCreate(iMutex, KNullDesC, KMutexOrdGeneral7);

	}

DSgChannel::~DSgChannel()

	{

	if (iMutex)

		{

		iMutex->Close(NULL);

		}

	for (TInt i = 0; i < iResources.Count(); ++i)

		{

		iResources[i].iResource->Close();

		}

	iResources.Close();

	}

TInt DSgChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	switch (aFunction)

		{

	case RSgDevice::EControlCreateResource:

		{

		RSgDevice::TCreateResourceArgs args;

		kumemget32(&args, a1, sizeof(RSgDevice::TCreateResourceArgs));

		TInt metaDataSize, maxMetaDataSize;

		Kern::KUDesInfo(*args.iMetaData, metaDataSize, maxMetaDataSize);

		__ASSERT_ALWAYS(metaDataSize <= KSgMaxMetaDataSize, Panic(ESgPanicMetaDataSizeTooBig));

		__ASSERT_ALWAYS(args.iDataSize >= 0, Panic(ESgPanicDataSizeNegative));

		TBuf8<KSgMaxMetaDataSize> metaData;

		Kern::KUDesGet(metaData, *args.iMetaData);

		TUint64 id;

		TInt err = CreateResource(args.iAttributes, metaData, args.iDataSize, id);

		kumemput32(a2, &id, sizeof(TUint64));

		return err;

		}

	case RSgDevice::EControlOpenResource:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		return OpenResource(id);

		}

	case RSgDevice::EControlCloseResource:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		return CloseResource(id);

		}

	case RSgDevice::EControlResourceAttributes:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		return static_cast<TInt>(ResourceAttributes(id));

		}

	case RSgDevice::EControlGetResourceMetaData:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		TBuf8<KSgMaxMetaDataSize> metaData;

		TInt err = GetResourceMetaData(id, metaData);

		if (err == KErrNone)

			{

			Kern::InfoCopy(*static_cast<TDes8*>(a2), metaData);

			}

		return err;

		}

	case RSgDevice::EControlResourceDataAddress:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		return reinterpret_cast<TInt>(ResourceDataAddress(id));

		}

	case RSgDevice::EControlResourceDataSize:

		{

		TUint64 id;

		kumemget32(&id, a1, sizeof(TUint64));

		return ResourceDataSize(id);

		}

	case RSgDevice::EControlGlobalResourceCount:

		return GlobalResourceCount();

	case RSgDevice::EControlLocalGraphicsMemoryUsed:

		return LocalGraphicsMemoryUsed();

	case RSgDevice::EControlGlobalGraphicsMemoryUsed:

		return GlobalGraphicsMemoryUsed();

	default:

		return KErrNotSupported;

		}

	}

TInt DSgChannel::CreateResource(TUint32 aAttribs, const TDesC8& aMetaData, TInt aDataSize, TUint64& aId)

	{

	aId = 0;

	NKern::ThreadEnterCS();

	DSgResource* resource;

	TInt err = SgExtension::CreateResource(aAttribs, aMetaData, aDataSize, resource);

	if (err != KErrNone)

		{

		NKern::ThreadLeaveCS();

		return err;

		}

	TInt handle = Kern::MakeHandleAndOpen(NULL, resource->DataChunk(), EOwnerProcess);

	if (handle < 0)

		{

		resource->Close();

		NKern::ThreadLeaveCS();

		return handle;

		}

	Kern::MutexWait(*iMutex);

	err = iResources.InsertInOrder(TResourceListItem(resource, handle), Compare);

	Kern::MutexSignal(*iMutex);

	if (err != KErrNone)

		{

		(void)Kern::CloseHandle(NULL, handle);

		resource->Close();

		NKern::ThreadLeaveCS();

		return err;

		}

	NKern::ThreadLeaveCS();

	aId = resource->Id();

	return KErrNone;

	}

TInt DSgChannel::OpenResource(TUint64 aId)

	{

	if (aId == 0)

		{

		return KErrArgument;

		}

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		Kern::MutexSignal(*iMutex);

		NKern::ThreadLeaveCS();

		return KErrAlreadyExists;

		}

	DSgResource* resource;

	TInt err = SgExtension::FindAndOpenResource(aId, resource);

	if (err != KErrNone)

		{

		Kern::MutexSignal(*iMutex);

		NKern::ThreadLeaveCS();

		return err;

		}

	TInt handle = Kern::MakeHandleAndOpen(NULL, resource->DataChunk(), EOwnerProcess);

	if (handle < 0)

		{

		resource->Close();

		Kern::MutexSignal(*iMutex);

		NKern::ThreadLeaveCS();

		return handle;

		}

	err = iResources.InsertInOrder(TResourceListItem(resource, handle), Compare);

	if (err != KErrNone)

		{

		(void)Kern::CloseHandle(NULL, handle);

		resource->Close();

		Kern::MutexSignal(*iMutex);

		NKern::ThreadLeaveCS();

		return err;

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return KErrNone;

	}

TInt DSgChannel::CloseResource(TUint64 aId)

	{

	if (aId == 0)

		{

		return KErrArgument;

		}

	TInt err = KErrNotFound;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		(void)Kern::CloseHandle(NULL, iResources[i].iChunkHandle);

		iResources[i].iResource->Close();

		iResources.Remove(i);

		err = KErrNone;

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return err;

	}

TUint32 DSgChannel::ResourceAttributes(TUint64 aId) const

	{

	if (aId == 0)

		{

		return 0;

		}

	TUint32 attribs = 0;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		attribs = iResources[i].iResource->Attributes();

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return attribs;

	}

TInt DSgChannel::GetResourceMetaData(TUint64 aId, TDes8& aMetaData) const

	{

	if (aId == 0)

		{

		return KErrArgument;

		}

	TInt err = KErrNotFound;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		err = iResources[i].iResource->GetMetaData(aMetaData);

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return err;

	}

TAny* DSgChannel::ResourceDataAddress(TUint64 aId) const

	{

	if (aId == 0)

		{

		return NULL;

		}

	TAny* addr = NULL;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		addr = Kern::ChunkUserBase(iResources[i].iResource->DataChunk(), &Kern::CurrentThread());

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return addr;

	}

TInt DSgChannel::ResourceDataSize(TUint64 aId) const

	{

	if (aId == 0)

		{

		return KErrArgument;

		}

	TInt ret = KErrNotFound;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

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

	if (i >= 0)

		{

		ret = iResources[i].iResource->DataSize();

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return ret;

	}

TInt DSgChannel::GlobalResourceCount() const

	{

	NKern::ThreadEnterCS();

	TInt ret = SgExtension::GlobalResourceCount();

	NKern::ThreadLeaveCS();

	return ret;

	}

TInt DSgChannel::LocalGraphicsMemoryUsed() const

	{

	TInt ret = 0;

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iMutex);

	TInt n = iResources.Count();

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

		{

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

		}

	Kern::MutexSignal(*iMutex);

	NKern::ThreadLeaveCS();

	return ret;

	}

TInt DSgChannel::GlobalGraphicsMemoryUsed() const

	{

	NKern::ThreadEnterCS();

	TInt ret = SgExtension::GlobalGraphicsMemoryUsed();

	NKern::ThreadLeaveCS();

	return ret;

	}

DSgChannel::TResourceListItem::TResourceListItem(DSgResource* aResource, TInt aChunkHandle)

	: iResource(aResource), iChunkHandle(aChunkHandle)

	{

	}

TInt DSgChannel::Compare(const TUint64* aId, const TResourceListItem& aResourceListItem)

	{

	return DSgResource::Compare(aId, *aResourceListItem.iResource);

	}

TInt DSgChannel::Compare(const TResourceListItem& aResourceListItem1, const TResourceListItem& aResourceListItem2)

	{

	return DSgResource::Compare(*aResourceListItem1.iResource, *aResourceListItem2.iResource);

	}