/*
* Copyright (c) 2008-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 "pci-ne.h"
#include "../naviengine_pci.h"
#include <naviengine.h>
#include <kernel/kern_priv.h>

//
// TChunkManager
//

TChunkManager::TChunkRecord::TChunkRecord(DPlatChunkHw* aChunk, TInt32 aSize)
	:iChunk(aChunk), iSize(aSize)
	{
	}

/**
A utitlity function so that we can find pci chunks structs in iChunks array
*/
TBool TChunkManager::TChunkRecord::ChunkComparator(const TChunkRecord& aKeyRecord, const TChunkRecord& aRecord)
	{
	return (aKeyRecord.iChunk==aRecord.iChunk);
	}

TChunkManager::TChunkManager(TMappingManager& aMapMan)
	:iMapMan(aMapMan), iChunks(), iSharedChunks(), iMutex(NULL)
	{
	_LIT(KChunkManMutex, "PCI_Chunk_Man_Mutex");
	TInt r = Kern::MutexCreate(iMutex, KChunkManMutex, KMutexOrdGeneral2);
	__NK_ASSERT_ALWAYS(KErrNone==r);
	}

TChunkManager::~TChunkManager()
	{
	iChunks.Reset();
	iSharedChunks.Reset();
	iMutex->Close(NULL);
	}


/**
@param aChunk a NULL pointer. Will be set to new chunk on success.
@param aPciAddress On success will be set to address of chunk buffer in PCI address space
@param aSize The size of the chunk to allocate
@return An errror code.
	- KErrNotFound All of Bridges BARS have been used up.
*/
TInt TChunkManager::AddChunk(DPlatChunkHw*& aChunk, TInt& aSize, TUint aAttributes, TUint32& aPciAddress)
	{
	NKern::ThreadEnterCS();
	Kern::MutexWait(*iMutex);

	DPlatChunkHw* chunk=NULL;
	TUint32 pciAddress=NULL;
	TInt32 size=aSize;

	TInt r=DoAddChunk(chunk, aSize, aAttributes, pciAddress);
	if(r==KErrNone)
		{
		aChunk=chunk;
		aPciAddress=pciAddress;
		aSize=size;
		}

	Kern::MutexSignal(*iMutex);
	NKern::ThreadLeaveCS();

	return r;
	}

/**
@param aPciAddress On success will be set to address of chunk buffer in PCI address space
@param aSize The size of the chunk to allocate
@return An errror code.
	- KErrNotFound All of Bridges BARS have been used up.
*/
TInt TChunkManager::DoAddChunk(DPlatChunkHw*& aChunk, TInt aSize, TUint aAttributes, TUint32& aPciAddress)
	{
	
	#ifdef _DEBUG	
	__ASSERT_CRITICAL;	
	__ASSERT_MUTEX(iMutex); 
	#endif

	TInt requestedSize=Clp2(aSize);
	//Although the client has specified aSize, the actual chunk we get may be larger as it will be rounded to a page size.
	//CreateChunk may adjust its size parameter to be the actual size allocated.
	TInt r = CreateChunk(aChunk, aSize, aAttributes);
	if(r!=KErrNone)
		return r;

	const TUint32 physicalAddress=aChunk->PhysicalAddress();
	
	//even if physical memory block was 4K, it is ok to have a smaller
	//pci mapping as long as its size is power of 2
	TInt mapSize = Min(requestedSize, aSize);
	r = iMapMan.CreateMapping(physicalAddress, mapSize, aPciAddress);

	//no point having chunk if no mapping in pci space.
	if(r!=KErrNone)
		{
		const TInt ret=DeleteChunk(aChunk, aSize);
		__NK_ASSERT_ALWAYS(KErrNone==ret);
		return r;
		}

	//remember the actual size of memory allocated to chunk
	const TChunkRecord newRecord(aChunk, aSize);
	r = iChunks.Append(newRecord);

	// delete chunk if a record of it can't be kept.
	if(r!=KErrNone)
		{
		const TInt ret=DeleteChunk(aChunk, aSize);
		__NK_ASSERT_ALWAYS(KErrNone==ret);
		return r;
		}

	return r;
	}

/**
Creates a chunk of specified size, but rounded up to at least a page.
@param aChunk On success will be set to the new chunk.
@param aSize Size of chunk required, on return will have modfied if size was rounded up.
@param aAttributes A bit mask of TMappingAttributes values.
@return
	- KErrNone
	- KErrNoMemory
*/
TInt TChunkManager::CreateChunk(DPlatChunkHw*& aChunk, TInt& aSize, TUint aAttributes)
	{
	aSize = Kern::RoundToPageSize(aSize);
	aSize = Clp2(aSize);
	
	NKern::ThreadEnterCS();

	TPhysAddr physicalAddress=NULL;
	TInt r=Epoc::AllocPhysicalRam(aSize, physicalAddress, Log2(aSize));
	if(r!=KErrNone)
		{
		__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::CreateChunk(): Phys memory alloc failed with error=%d, size=%d (0x%X)", r, aSize, aSize));
		NKern::ThreadLeaveCS();
		return r;
		}

	r = DPlatChunkHw::New(aChunk,physicalAddress, aSize, aAttributes);
	if(r!=KErrNone)
		{
		__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::CreateChunk(): Chunk creation failed with status %d, phys addr=0x%08x, size=%d (0x%X)", r, physicalAddress, aSize, aSize));
		const TInt ret=Epoc::FreePhysicalRam(physicalAddress, aSize);
		__NK_ASSERT_ALWAYS(KErrNone==ret);
		NKern::ThreadLeaveCS();
		return r;
		}

	NKern::ThreadLeaveCS();

	__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::CreateChunk(): Chunk created at 0x%08x, phys addr=0x%08x, size=%d (0x%X)", aChunk, physicalAddress, aSize, aSize));
	return r;
	}


/**
Delete and remove PCI mapping for a chunk previously created by this class

@param aChunk pointer to a chunk to remove.
@return
	- KErrNone
	- KErrNotFound aChunk was not allocated by this class
*/
TInt TChunkManager::RemoveChunk(DPlatChunkHw* aChunk)
	{
	NKern::ThreadEnterCS();
	Kern::MutexWait(*iMutex);

	__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::RemoveChunk(): Removing chunk at 0x%08X", aChunk));
	const TChunkRecord key(aChunk, 0);
	TInt index=iChunks.Find(key, TIdentityRelation<TChunkRecord>(TChunkRecord::ChunkComparator) );
	TInt r=KErrNone;
	if(index!=KErrNotFound)
		{
		r = iMapMan.RemoveMapping(iChunks[index].iChunk->PhysicalAddress() );
		__NK_ASSERT_ALWAYS(KErrNone==r);
		r = DeleteChunk(iChunks[index].iChunk, iChunks[index].iSize);
		__NK_ASSERT_ALWAYS(r==KErrNone);

		iChunks.Remove(index);
#ifdef _DEBUG
		//free space when entry removed
		iChunks.Compress();
#endif
		}
	else
		r=index;

	Kern::MutexSignal(*iMutex);
	NKern::ThreadLeaveCS();

	return r;
	}

/**
Delete chunk and remove aSize of physical RAM
*/
TInt TChunkManager::DeleteChunk(DPlatChunkHw* aChunk, TInt aSize)
	{
	const TPhysAddr address = aChunk->PhysicalAddress();
	NKern::ThreadEnterCS();
	__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::DeleteChunk(): Freeing physical RAM: %d (0x%X) bytes at 0x%X ", aSize, aSize, address));
	Kern::SafeClose(reinterpret_cast<DObject*&>(aChunk), NULL);
	TInt r=Epoc::FreePhysicalRam(address,aSize);
	NKern::ThreadLeaveCS();
	return r;
	}


//
// Shared Chunk methods
//

TChunkManager::TSCRecord::TSCRecord(DChunk* aChunk, TUint32 aPhysAddr)
	:iChunk(aChunk), iPhysAddr(aPhysAddr), iMapped(EFalse), iSize(0)
	{
	}


TBool TChunkManager::TSCRecord::ChunkComparator(const TSCRecord& aKeyRecord, const TSCRecord& aRecord)
	{
	return (aKeyRecord.iPhysAddr==aRecord.iPhysAddr);
	}

TInt TChunkManager::AddChunk(DChunk*& aChunk, TChunkCreateInfo& aAttributes, TUint aOffset, TUint& aSize, TUint32& aPciAddress)
	{
	NKern::ThreadEnterCS();
	Kern::MutexWait(*iMutex);

	DChunk* chunk=NULL;
	TUint32 pciAddress;

	TInt r=DoAddChunk(chunk, aAttributes, aOffset, aSize, pciAddress);
	if(r==KErrNone)
		{
		aChunk=chunk;
		aPciAddress=pciAddress;
		}
	
	Kern::MutexSignal(*iMutex);
	NKern::ThreadLeaveCS();

	return r;
	}

void TChunkManager::RemoveChunk(TUint32 aPhysicalAddress)
	{
	NKern::ThreadEnterCS();
	Kern::MutexWait(*iMutex);

	const TSCRecord key(NULL, aPhysicalAddress);

	TInt index=iSharedChunks.Find(key, TIdentityRelation<TSCRecord>(TSCRecord::ChunkComparator) );
	__NK_ASSERT_ALWAYS(index!=KErrNotFound);

	TSCRecord& record(iSharedChunks[index]);
	__NK_ASSERT_DEBUG(record.iPhysAddr==aPhysicalAddress);

	// We will always have to free RAM
	const TInt size=record.iSize;
	__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::RemoveChunk(TUint32) Freeing physical RAM: %d (0x%X) bytes at 0x%X ", size, size, aPhysicalAddress));
	NKern::ThreadEnterCS();
	TInt r = Epoc::FreePhysicalRam(aPhysicalAddress, size);
	NKern::ThreadLeaveCS();
	__NK_ASSERT_ALWAYS(KErrNone==r);

	if(record.iMapped)
		{
		__KTRACE_OPT(KPCI,
			Kern::Printf("TChunkManager::RemoveChunk(TUint32) Removing PCI mapping for RAM: %d (0x%X) bytes at 0x%X ",
				size, size, record.iPhysAddr));

		TInt r=iMapMan.RemoveMapping(record.iPhysAddr);
		__NK_ASSERT_ALWAYS(KErrNone==r);
		}
	else
		{
		__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::RemoveChunk(TUint32) No PCI mapping for memory")); 
		}

	iSharedChunks.Remove(index);
#ifdef _DEBUG
	//free space when entry removed
	iSharedChunks.Compress();
#endif

	Kern::MutexSignal(*iMutex);
	NKern::ThreadLeaveCS();
	}

TInt TChunkManager::DoAddChunk(DChunk*& aChunk, TChunkCreateInfo& aAttributes, TUint aOffset, TUint& aSize, TUint32& aPciAddress)
	{
	TInt r = iSharedChunks.Append(TSCRecord(NULL, NULL));
	if(r!=KErrNone)
		{
		return r;
		}

	const TInt count = iSharedChunks.Count();
	TSCRecord& newRecord(iSharedChunks[count-1]);
	//Although the client has specified aSize, the actual chunk we get may be larger as it will be rounded to a page size.
	//CreateChunk may adjust its size parameter to be the actual size allocated.
	r = CreateChunk(aChunk, aAttributes, aOffset, aSize, newRecord);
	if(r!=KErrNone)
		{
		//If newRecord is not populated we must remove it.
		//If it has been populated, the chunk record will
		//be removed by the chunk's cleanup DFC and we must leave
		//it alone.
		if(newRecord.iChunk==NULL)
			{
			iSharedChunks.Remove(count-1);
#ifdef _DEBUG
			//free space when entry removed
			iSharedChunks.Compress();
#endif
			}

		return r;
		}

	//map all of the commited memory, which may exceed what the client requested
	//The minumum memory allocation is 4k
	//And memory must also be mapped in powers of 2 eg. A request for 11k would create
	//and map 16K


	//need CS since if we succeed in creating a mapping we
	//must be allowed to toggle the iMapped flag in the record array.
	NKern::ThreadEnterCS();
	TInt size=aSize;
	r = iMapMan.CreateMapping(newRecord.iPhysAddr, size, aPciAddress);

	//no point having chunk if no mapping in pci space.
	if(r!=KErrNone)
		{
		//chunk will proceed to cleanup memory only
		TBool destructionPending=Kern::ChunkClose(aChunk);
		NKern::ThreadLeaveCS();
		__NK_ASSERT_ALWAYS(destructionPending);
		return r;
		}
	newRecord.iMapped=ETrue;
	NKern::ThreadLeaveCS();

	__NK_ASSERT_ALWAYS(r==KErrNone); //we reserved space for this

	return r;
	}

TInt TChunkManager::CreateChunk(DChunk*& aChunk, TChunkCreateInfo& aAttributes, TUint aOffset, TUint& aSize, TSCRecord& aRecord)
	{
	//natuarally align aSize.
	const TInt size=Clp2(aSize);
	const TInt align=Log2(size);	

	TPhysAddr physicalAddress=NULL;

	NKern::ThreadEnterCS();
	TInt r = Epoc::AllocPhysicalRam(size, physicalAddress, align);	
    if(r != KErrNone)
	    {
		__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::CreateChunk(DChunk*): Phys memory alloc failed with error=%d, size=%d (0x%X)", r, size, size));
		NKern::ThreadLeaveCS();
		return r; 
	    }
	
	//now that we know the physical address of our memory
	//we can create the cleanup object
	TNaviEngineChunkCleanup* cleanup= new TNaviEngineChunkCleanup(*this, physicalAddress);
	if(cleanup == NULL)
		{
		//free physical ram
		r = Epoc::FreePhysicalRam(physicalAddress, size);
		__NK_ASSERT_ALWAYS(KErrNone==r);
		NKern::ThreadLeaveCS();
		return KErrNoMemory;
		}

	//Since we are mapping in memory we alloc'd
	//the chunk is not responsible for freeing it.
	aAttributes.iOwnsMemory=EFalse;

	//ensure that max size is large enough to contain the rounded physical block plus specified guard offsets
	//at each end
	aAttributes.iMaxSize=Max(aAttributes.iMaxSize, size+(2*aOffset));

	aAttributes.iDestroyedDfc = cleanup;

	TLinAddr kernAddr;
	TUint32 attribs;
	r=Kern::ChunkCreate(aAttributes, aChunk, kernAddr, attribs);
    if(r != KErrNone)
	    {
		//free physical ram
		TInt err = Epoc::FreePhysicalRam(physicalAddress, size);
		__NK_ASSERT_ALWAYS(KErrNone==err);

		delete cleanup;
		NKern::ThreadLeaveCS();
		return r;
	    }
	//At this point, the cleanup object will look after its own destruction
	//when the chunk is closed
	cleanup=NULL;
	
	//these will be requird in order to free physical memory if we have to close the chunk
	aRecord.iPhysAddr=physicalAddress;
	aRecord.iChunk=aChunk;	
	aRecord.iSize=size;
		
	r=Kern::ChunkCommitPhysical(aChunk, aOffset, size, physicalAddress);  

	if(r!=KErrNone)
		{
		TBool destructionPending=Kern::ChunkClose(aChunk);
		__NK_ASSERT_ALWAYS(destructionPending);
		NKern::ThreadLeaveCS();
		return r;
		}

	//report back size commited
	aSize=size;
	__KTRACE_OPT(KPCI, Kern::Printf("TChunkManager::CreateChunk(DChunk*): Chunk created at 0x%08x, phys addr=0x%08x, size=%d (0x%X)",
		aChunk, physicalAddress, aSize, aSize));

	NKern::ThreadLeaveCS();
	return r;
	}