// 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 the License "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:

// e32\drivers\locmedia\dmasupport.cpp

// 

//

#include <kernel/kernel.h>

#include <kernel/cache.h>

#include "locmedia.h"

#include "dmasupport.h"

#include "dmasupport.inl"

#define PHYSADDR_FAULT()	Kern::Fault("TLOCDRV-PHYS-ADDR",__LINE__)

//#define __DEBUG_DMASUP__

#ifdef __DEBUG_DMASUP__

#define __KTRACE_DMA(p) {p;}

#else

#define __KTRACE_DMA(p)

#endif

TInt DDmaHelper::iPageSize;

TInt DDmaHelper::iPageSizeLog2;

TInt DDmaHelper::iPageSizeMsk;

/******************************************************************************

 DDmaHelper

 ******************************************************************************/

const TPhysAddr KPhysMemFragmented = KPhysAddrInvalid;

TUint32 Log2(TUint32 aVal)

	{	

    __ASSERT_COMPILE(sizeof(TUint32) == 4);

    TUint32 bitPos=31;

    if(!(aVal >> 16)) {bitPos-=16; aVal<<=16;}

    if(!(aVal >> 24)) {bitPos-=8;  aVal<<=8 ;}

    if(!(aVal >> 28)) {bitPos-=4;  aVal<<=4 ;}

    if(!(aVal >> 30)) {bitPos-=2;  aVal<<=2 ;}

    if(!(aVal >> 31)) {bitPos-=1;}

    return bitPos;

	}

TBool IsPowerOfTwo(TInt aNum)

//

// Returns ETrue if aNum is a power of two

//

	{

	return (aNum != 0 && (aNum & -aNum) == aNum);

	}

void DDmaHelper::ResetPageLists()

	{

	iFragLen = 0;

	iFragLenRemaining = 0;

	}

DDmaHelper::DDmaHelper()

	{

	iPageSize = Kern::RoundToPageSize(1);

	__ASSERT_ALWAYS(IsPowerOfTwo(iPageSize), PHYSADDR_FAULT());

	iPageSizeLog2 = Log2(iPageSize);

	iPageSizeMsk = iPageSize-1;

	}

DDmaHelper::~DDmaHelper()

	{

	delete [] iPageArray;

	delete [] iPageList;

	if (iPhysicalPinObject)

		{

		NKern::ThreadEnterCS();

		Kern::DestroyPhysicalPinObject(iPhysicalPinObject);

		NKern::ThreadLeaveCS();

		}

	}

/**

Constructs the DDmaHelper object 

@param aLength The maximum length of data mapped by this object.

			   Should be a multiple of the page size 

@param aMediaBlockSize The minimum amount data that the media can transfer in read / write operations

@param aDmaAlignment The memory alignment required by the media devices DMA controller. (i.e. word aligned = 2)

@return KErrNone,if successful;

		KErrNoMemory, if unable to create Page Array's.

*/

TInt DDmaHelper::Construct(TInt aLength, TInt aMediaBlockSize, TInt aDmaAlignment)

	{

	__ASSERT_ALWAYS(aMediaBlockSize > 0, PHYSADDR_FAULT());

	__ASSERT_ALWAYS(IsPowerOfTwo(aMediaBlockSize), PHYSADDR_FAULT());

	__ASSERT_ALWAYS(aLength > 0, PHYSADDR_FAULT());

	__ASSERT_ALWAYS(aLength > iPageSize, PHYSADDR_FAULT());

	// This code assumes that the media block size (normally 512) is >= the processor's 

	// cache-line size (typically 32 bytes). This may not be true for future processors.

	// If the cache-line size was 1024, for example,  reading 512 bytes into a client's 

	// buffer & then calling Cache::SyncMemoryAfterDmaRead would invalidate an entire 1024 

	// bytes in the user's address space.

	TUint cacheLineSize = Cache::DmaBufferAlignment();

	__ASSERT_ALWAYS(IsPowerOfTwo(cacheLineSize), PHYSADDR_FAULT());

	if (cacheLineSize > (TUint) aMediaBlockSize)

		return KErrNotSupported;

	//Check whether Kernel supports physical memory pinning:

	TInt mm = Kern::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;

	if (mm >= EMemModelTypeFlexible)

		{

		// Flexible memory model supports physical pinning for user (and Kernel) memory that

		// is the subject of DMA transfer.

		// Physical memory pinning ensures that:

		// - physical memory is not moved by RAM defragmentation.

		// - it is safe to to DMA against it or do sync cache (using new interface) even if/when

		// the owner of the memory (e.g. untrusted user aplication) decomits memory or panics.

		// For details @see Kern::PinPhysicalMemory.

		// Cache Sync of physically pinned memory on flexible memory model is done by:

		//  - Cache::SyncPhysicalMemoryBeforeDmaWrite

		//  - Cache::SyncPhysicalMemoryBeforeDmaRead

		//  - Cache::SyncPhysicalMemoryAfterDmaRead

		iPhysPinningAvailable = ETrue;

		__KTRACE_DMA(Kern::Printf("Memory model (%d) supports physical pining\n",mm));

		NKern::ThreadEnterCS();

		TInt r=Kern::CreatePhysicalPinObject(iPhysicalPinObject);

		NKern::ThreadLeaveCS();

		if (r) return r;

		}

	else

		{

		// Memory models before flexible do not support memory pinning.

		// The driver has to use  PrepareMemoryForDMA/ReleaseMemoryFromDMA Kernel interface 

		// that ensures that physical memory won't be moved by RAM defragmentation module.

		// However, Kernel relies on assumption that the user memory won't dissapear (e.g. by

		// user client closing the chunk or panics), as it would lead to Kernel crash.

		// For that reason, the only use case for DMA transfer into user memory is File System's

		// read/write buffer - as it is assumed that File System is trusted component.

		// To mark its buffers(s) for DMA transfer, File Sytem must call UserSvr::RegisterTrustedChunk

		// before DMA transfer starts.

		// Cache sync. operations before/after DMA transfer must be done by using the old Cache interface:

		//  - Cache::SyncMemoryBeforeDmaWrite

		//  - Cache::SyncMemoryBeforeDmaRead

		//  - Cache::SyncMemoryAfterDmaRead

		// As they all require linear address as input, these methods also rely on File System buffers

		// to be in valid state during sync calls.

		iPhysPinningAvailable = EFalse;

		__KTRACE_DMA(Kern::Printf("Memory model (%d) doesn't support physical pining\n",mm));

		iPhysicalPinObject = NULL;

		}

	iMaxPages = (aLength >> iPageSizeLog2)-1;

	// 2 Additional pages for page straddling

	iPageArray = new TPhysAddr[iMaxPages+2];

	if (iPageArray != NULL)

		{

		iPageList = new TPageList[iMaxPages];

		if (iPageList != NULL)

			{

			iMediaBlockSize = aMediaBlockSize;

			iMediaBlockSizeMask = TInt64(iMediaBlockSize - 1);

			iDmaAlignment = aDmaAlignment;

			__KTRACE_DMA(Kern::Printf("-PHYSADDR: Construct iMaxPages(%d), MediaBlocks(%d), DMAalign(%d)",iMaxPages,iMediaBlockSize,iDmaAlignment));

			return KErrNone;

			}

		delete [] iPageArray; iPageArray = NULL;

		}

	iMaxPages = 0;

	return KErrNoMemory;

	}

/**

 * Each Read/Write request is examined to determine if the descriptor that 

 * is referenced is mapped to a physical memory object; 

 * if so it prepares the memory, updates the request with physical memory information

 * and issues the request.

 * If a request does not make use of physical memory or is not configured correctly the

 * request is passed through without modification.

 */

TInt DDmaHelper::SendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress)

	{

	DPrimaryMediaBase& primaryMedia = *aReq.Drive()->iPrimaryMedia;

	TInt reqId = aReq.Id();

	if (reqId != DLocalDrive::ERead && reqId != DLocalDrive::EWrite)

		return aReq.SendReceive(&primaryMedia.iMsgQ);

	if ((I64HIGH(aReq.Length()) > 0) || (aReq.Length() < iMediaBlockSize))

		return aReq.SendReceive(&primaryMedia.iMsgQ);

	// If more than one user thread tries to access the drive, then bail out as there is 

	// only one DDmaHelper object per TLocDrv. Normally this shouldn't ever happen unless

	// a client app accesses the drive directly using TBusLOcalDrive or the file system is 

	// asynchronous (i.e. there is a separate drive thread) but the file server message is 

	// flagged as synchronous - e.g. EFsDrive

	if (TInt(__e32_atomic_add_ord32(&iLockCount, 1)) > 0)	// busy ?

		{

		__KTRACE_DMA(Kern::Printf("-PHYSADDR: BUSY"));

		__e32_atomic_add_ord32(&iLockCount, TUint32(-1));

		return aReq.SendReceive(&primaryMedia.iMsgQ);

		}

	// make a copy of the request 

	iMemoryType = EUnknown;

	iReq = &aReq;

	iReqId = reqId;

	iReqPosClient = iReq->Pos();

	iReqLenClient = I64LOW(iReq->Length());

	iReqRemoteDesOffset = iReq->RemoteDesOffset();

	iReqFlags = iReq->Flags();

	iRemoteThread = iReq->RemoteThread();

	iCurrentThread = &Kern::CurrentThread();

	iOwningThread = iRemoteThread ? iRemoteThread : iCurrentThread;

	iChunk = NULL;

	iChunkOffset = 0;

	iLinAddressUser = NULL;

	iLenConsumed = 0;

	// point to the start of the descriptor

	iLinAddressUser = aLinAddress - iReqRemoteDesOffset;

	// Need to check descriptors from both direct Clients (i.e. file cache, RemoteThread == NULL )

	// and Remote Server Clients (file server clients, RemoteThread != NULL)

	// Shared Memory can potentially be used by both remote server and direct clients

	NKern::ThreadEnterCS();

	iChunk = Kern::OpenSharedChunk(iOwningThread, (const TAny*) iLinAddressUser, ETrue, iChunkOffset);

	NKern::ThreadLeaveCS();

	TInt fragments = 0;

	TInt r;

	do

		{

		__KTRACE_DMA(Kern::Printf(">PHYSADDR:SendReceive() iReqLen %d; iLenConsumed %d; fragments %d",iReqLen, iLenConsumed, fragments));

		r = RequestStart();

		if (r != KErrNone)

			{

			if (iChunk)

				{

				NKern::ThreadEnterCS();

				Kern::ChunkClose(iChunk);

				iChunk = NULL;

				NKern::ThreadLeaveCS();

				}

			__KTRACE_DMA(Kern::Printf("<PHYSADDR:SendReceive()- r:%d",r));

			iMemoryType = EUnknown;

			__e32_atomic_add_ord32(&iLockCount, TUint32(-1));

			return fragments ? r : iReq->SendReceive(&primaryMedia.iMsgQ);

			}

		else

			{

			iReq->Flags() |= TLocDrvRequest::EPhysAddr;

			}

		__KTRACE_DMA(Kern::Printf("-PHYSADDR:SendReceive() rThread %08X pos %08lX, len %d addr %08X off %08X", 

				iRemoteThread, iReq->Pos(), I64LOW(iReq->Length()), iLinAddressUser, iReqRemoteDesOffset));

		__ASSERT_DEBUG(iReq->Length() == FragLength(), PHYSADDR_FAULT());

		__ASSERT_DEBUG(iReq->Length() != 0, PHYSADDR_FAULT());

		// reinstate iValue in case overwritten by DMediaPagingDevice::CompleteRequest()

		iReq->iValue = iReqId;

		r = iReq->SendReceive(&primaryMedia.iMsgQ);

		// The media driver could potentially choose to deal with the request 

		// without accessing physical memory (e.g. if the data is already cached).

		iLenConsumed += iFragLenRemaining;

		RequestEnd();

		ResetPageLists();

		fragments++;

		}

	while(r == KErrNone && LengthRemaining() > 0);

	if (iChunk)		

		{

		NKern::ThreadEnterCS();

		Kern::ChunkClose(iChunk);

		iChunk = NULL;

		NKern::ThreadLeaveCS();

		}

	// Set remote descriptor length to iReqLenClient

	if (iReqId == DLocalDrive::ERead && r == KErrNone)

		r = UpdateRemoteDescriptorLength(iReqLenClient);

	__KTRACE_DMA(Kern::Printf("<PHYSADDR:SendReceive()"));

	iMemoryType = EUnknown;

	__e32_atomic_add_ord32(&iLockCount, TUint32(-1));

	return r;

	}

/**

 * Each read/write request is split into one or more DMA "fragments".

 * The maximum size of each fragment depends on the size of iPageArray[].

 * Subsquent calls to RequestStart maybe required to complete a request.

 * 

 * The physical address is checked for DMA alignment or the possibility of 

 * eventually alignment due to mis-aligned start/end media blocks.

 * 

 * A DMA "fragment" can be split over a number of pages as follows :

 * ----------------------------------------------------------

 * |    4K    |    4K    |    4K    |    4K    |

 * ----------------------------------------------------------

 *      ********************************		: region to be read

 * <----------- iFragLen ----------->

 * 

 * The pages may not be physically contiguous; if they are not, 

 * then they are supplied to the media driver one contiguous 

 * sequent at a time by GetPhysicalAddress()

 **/

TInt DDmaHelper::RequestStart()

	{

	__KTRACE_DMA(Kern::Printf(">PHYSADDR:RequestStart()"));

	iIndex = 0;

	TLinAddr startAddr = LinAddress();

	TInt64 startPos = iReqPosClient + iLenConsumed;

	TInt mediaBlockOffset = BlockOffset(startPos);

	TInt addrBlockOffset = BlockOffset(startAddr);

	TInt length = Min(LengthRemaining(), MaxFragLength());

	iPageArrayCount = iPageListCount = 0;

	TLinAddr firstPageStart = PageAlign(startAddr);

	TLinAddr lastPageStart = PageAlign(startAddr + length + iPageSize - 1);

	iPageArrayCount = (lastPageStart - firstPageStart + 1) >> iPageSizeLog2;

	iMemoryType = EUnknown;

	iPhysAddr = KPhysMemFragmented; // Default - Mark memory as fragmented

	//*************************************

	// Check Physical Page Alignment!!	

	//*************************************

	if (!IsBlockAligned(startPos))

		{

		// Will DMA align at next block alignment? such that DMA can be used

		TInt ofset = I64LOW((startPos + iMediaBlockSize) & (iMediaBlockSize-1));

		ofset = iMediaBlockSize - ofset;

		if (!IsDmaAligned(startAddr))

			{			

			__KTRACE_DMA(Kern::Printf("<PHYSADDR:RequestStart() - not DMA Aligned pos 0x%x addr 0x%x)",I64LOW(startPos), startAddr));

			return KErrNotSupported;

			}

		}

	else 

		{ //block aligned!

		if (!IsDmaAligned(startAddr))

			{

			__KTRACE_DMA(Kern::Printf("<PHYSADDR:RequestStart() - not DMA Aligned (0x%x)",startAddr));

			return KErrNotSupported;

			}

		}

	//************************************************

	// Check for possible striping of RAM pages vs Media blocks

	// i.e. Media blocks which may straddle 2 non contiguous pages. 

	//************************************************

	if (mediaBlockOffset != addrBlockOffset)

		{

		__KTRACE_DMA(Kern::Printf("<PHYSADDR:RequestStart() - Frag / not block aligned: pos 0x%x addr 0x%x", I64LOW(startPos), startAddr));

		return KErrNotSupported;

		}

	//************************************************

	// Is it File Server Cache request ?

	//************************************************

	if (iChunk == NULL &&				// Not Shared memory

		iRemoteThread == NULL &&		// Direct Client Request

		IsPageAligned(startAddr) &&

		IsBlockAligned(startPos) &&

		(iPageArrayCount > 0) )

		{

		TLinAddr firstPageAddr = PageAlign(startAddr); //ensure that it is page aligned.

		TInt r = KErrNone;

		if (iPhysPinningAvailable)

			{

			TBool readOnlyMem = (iReqId == DLocalDrive::EWrite); 

			r =  Kern::PinPhysicalMemory(iPhysicalPinObject,  firstPageAddr, iPageArrayCount << iPageSizeLog2,

					readOnlyMem, iPhysAddr, iPageArray, iMapAttr, iPageColour, iCurrentThread);

			}

		else

			{

			NKern::ThreadEnterCS();

			r = Kern::PrepareMemoryForDMA(iCurrentThread, (void*)firstPageAddr, iPageArrayCount << iPageSizeLog2, iPageArray);

			NKern::ThreadLeaveCS();

			}

		if (r != KErrNone) 

			return r;

		iMemoryType = EFileServerChunk;

		__KTRACE_DMA(Kern::Printf("-PHYSADDR:RequestStart() - EFileServerChunk"));

		}

	//****************************

	// Is it shared chunk ?

	//****************************

	else if (iChunk)

		{

		// calculate chunk offset of start of first page

		TInt offset = iChunkOffset + iReqRemoteDesOffset+ iLenConsumed;

		TInt r = Kern::ChunkPhysicalAddress(iChunk, offset, length, iLinAddressKernel, iMapAttr, iPhysAddr, iPageArray);

		if (r < KErrNone) 

			return r;  // 0 = Contiguous Memory, 1 = Fragmented/Dis-Contiguous Memory

		iMemoryType = ESharedChunk;

		__KTRACE_DMA(Kern::Printf("-PHYSADDR:RequestStart() - ESharedChunk"));

		}

	else

		{

		__KTRACE_DMA(Kern::Printf("<PHYSADDR:RequestStart() - EUnknown"));

		return KErrNotFound;

		}

	SetFragLength(length);

	//************************************************

	// Build Contiguous Page list

	//************************************************

	BuildPageList();

	//************************************************

	// Set up request parameters for this fragment 

	//************************************************

	iReq->Length() = MAKE_TINT64(0, length);

	iReq->Pos() = iReqPosClient + iLenConsumed;

	iReq->RemoteDesOffset() = iReqRemoteDesOffset + iLenConsumed;

	// restore EAdjusted flag to ensure iReq->Pos() is adjusted correctly

	iReq->Flags()&= ~TLocDrvRequest::EAdjusted;

	iReq->Flags()|= (iReqFlags & TLocDrvRequest::EAdjusted);

	//************************************************

	// Sync memory

	//************************************************

	__KTRACE_DMA(Kern::Printf(">SYNC-PHYSADDR:addr 0x%x len %d", startAddr, length));

	// Only sync whole blocks: it is assumed that the media driver will transfer 

	// partial start and end blocks without DMA

	TInt startBlockPartialLen = IsBlockAligned(startPos) ? 0 : iMediaBlockSize - BlockOffset(startPos);

	TInt blockLen = (TInt) BlockAlign(length - startBlockPartialLen);

	if (iReqId == DLocalDrive::EWrite)

		{

		if (iMemoryType == ESharedChunk)

			{

			Cache::SyncMemoryBeforeDmaWrite(iLinAddressKernel+startBlockPartialLen, blockLen, iMapAttr);

			}

		else // (iMemoryType == EFileServerChunk)

			{

			if (iPhysPinningAvailable)

				Cache::SyncPhysicalMemoryBeforeDmaWrite(iPageArray, iPageColour, startBlockPartialLen, blockLen, iMapAttr);

			else

				Cache::SyncMemoryBeforeDmaWrite(startAddr+startBlockPartialLen, blockLen);

			}

		}

	else

		{

		if (iMemoryType == ESharedChunk)

			Cache::SyncMemoryBeforeDmaRead(iLinAddressKernel, length, iMapAttr);

		else // (iMemoryType == EFileServerChunk)

			{

			if (iPhysPinningAvailable)

				Cache::SyncPhysicalMemoryBeforeDmaRead(iPageArray, iPageColour, 0, length, iMapAttr);

			else

				Cache::SyncMemoryBeforeDmaRead(startAddr, length);

			}

		}

	__KTRACE_DMA(Kern::Printf("<PHYSADDR:RequestStart()"));

	return KErrNone;

	}

/**

 * After read requests this method synchronous the current physical memory in use.

 */

void DDmaHelper::RequestEnd()

	{

	__KTRACE_DMA(Kern::Printf(">PHYSADDR:RequestEnd()"));

	__ASSERT_DEBUG(iReqId == DLocalDrive::ERead || iReqId == DLocalDrive::EWrite, PHYSADDR_FAULT());

	__ASSERT_DEBUG(iMemoryType == ESharedChunk || iMemoryType == EFileServerChunk, PHYSADDR_FAULT());

	TInt length = FragLength();	// len of data just transferred

	TLinAddr startAddr = LinAddress() - length;

	// Sync the memory : but not if the media driver has decided to transfer ALL the data using IPC rather than DMA.

	// It is assumed that the media driver will transfer partial start & end blocks using IPC, but it may also choose 

	// to use IPC for the ENTIRE fragment when read/writing at the end of the media (see medmmc.cpp)

	if (iFragLenRemaining < length && iReqId == DLocalDrive::ERead)

		{

		TInt64 startPos = iReq->Pos();

		TInt startBlockPartialLen = IsBlockAligned(startPos) ? 0 : iMediaBlockSize - BlockOffset(startPos);

		TInt blockLen = (TInt) BlockAlign(length - startBlockPartialLen);

		if (iMemoryType == ESharedChunk)

			{

			Cache::SyncMemoryAfterDmaRead(iLinAddressKernel + startBlockPartialLen, blockLen);