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

// Media driver for MultiMediaCard Flash device

// 

//

#include "mmc.h" 

#include "pbusmedia.h"

#include <drivers/emmcptn.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "locmedia_ost.h"

#ifdef __VC32__

#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

#endif

#include "medmmcTraces.h"

#endif

#if defined(__DEMAND_PAGING__)

	// If in debug mode, enable paging stats and their retrieval using DLocalDrive::EControlIO

	#if defined( _DEBUG)

		#define __TEST_PAGING_MEDIA_DRIVER__

	#endif

	#include "mmcdp.h"

#endif

#ifndef BTRACE_PAGING_MEDIA

	#undef BTraceContext8

	#define BTraceContext8(aCategory,aSubCategory,a1,a2) 

#endif	// BTRACE_PAGING_MEDIA

// Enables reliable writes for system drives

#define _ENABLE_EMMC_RELIABLE_WRITE_

// Enable this macro to debug cache: 

// NB The greater the number of blocks, the slower this is...

//#define _DEBUG_CACHE

#ifdef _DEBUG_CACHE

#define __ASSERT_CACHE(c,p) (void)((c)||(p,0))

#else

#define __ASSERT_CACHE(c,p)

#endif

#include "medmmc.h"

GLREF_C TInt GetMediaDefaultPartitionInfo(TMBRPartitionEntry& aPartitionEntry, TUint16& aReservedSectors, const TMMCard* aCardP);

GLREF_C TBool MBRMandatory(const TMMCard* aCardP);

GLREF_C TBool CreateMBRAfterFormat(const TMMCard* aCardP);

GLREF_C TInt BlockSize(const TMMCard* aCardP);

GLREF_C TInt EraseBlockSize(const TMMCard* aCardP);

extern  TInt GetCardFormatInfo(const TMMCard* aCardP, TLocalDriveCapsV5& aCaps);

IMPORT_C extern const TUint KTRIMEnabled;

const TInt KStackNumber = 0;

const TInt KIdleCurrentInMilliAmps = 1;

const TInt KMBRFirstPartitionEntry=0x1BE;

template <class T>

inline T UMin(T aLeft,T aRight)

	{return(aLeft<aRight ? aLeft : aRight);}

class DPhysicalDeviceMediaMmcFlash : public DPhysicalDevice

	{

public:

	DPhysicalDeviceMediaMmcFlash();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Validate(TInt aDeviceType, const TDesC8* aInfo, const TVersion& aVer);

	virtual TInt Info(TInt aFunction, TAny* a1);

	};

// these should be static const members of DMmcMediaDriverFlash, but VC doesn't support this

const TInt64 KInvalidBlock = -1;

const TInt KNoCacheBlock = -1;

// ======== DPhysicalDeviceMediaMmcFlash ========

DPhysicalDeviceMediaMmcFlash::DPhysicalDeviceMediaMmcFlash()

	{

	OstTraceFunctionEntry1( DPHYSICALDEVICEMEDIAMMCFLASH_DPHYSICALDEVICEMEDIAMMCFLASH_ENTRY, this );

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:ctr"));

	iUnitsMask = 0x01;

	iVersion = TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);

	OstTraceFunctionExit1( DPHYSICALDEVICEMEDIAMMCFLASH_DPHYSICALDEVICEMEDIAMMCFLASH_EXIT, this );

	}

TInt DPhysicalDeviceMediaMmcFlash::Install()

	{

	OstTraceFunctionEntry1( DPHYSICALDEVICEMEDIAMMCFLASH_INSTALL_ENTRY, this );

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:ins"));

	_LIT(KDrvNm, "Media.MmcF");

	TInt r = SetName(&KDrvNm);

	OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_INSTALL_EXIT, this, r );

	return r;

	}

void DPhysicalDeviceMediaMmcFlash::GetCaps(TDes8& /* aDes */) const

	{

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:cap"));

	}

TInt DPhysicalDeviceMediaMmcFlash::Info(TInt aFunction, TAny* /*a1*/)

//

// Return the priority of this media driver

//

	{

	OstTraceExt2(TRACE_FLOW, DPHYSICALDEVICEMEDIAMMCFLASH_INFO_ENTRY ,"DPhysicalDeviceMediaMmcFlash::Info;aFunction=%d;this=%x", aFunction, (TUint) this);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:info"));

	if (aFunction==EPriority)

	    {

		OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_INFO_EXIT1, this, KMediaDriverPriorityNormal );

		return KMediaDriverPriorityNormal;

	    }

	// Don't close media driver when peripheral bus powers down. This avoids the need for Caps() to power up the stack.

	if (aFunction==EMediaDriverPersistent)

	    {

		OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_INFO_EXIT2, this, KErrNone );

		return KErrNone;

	    }

	OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_INFO_EXIT3, this, KErrNotSupported );

	return KErrNotSupported;

	}

TInt DPhysicalDeviceMediaMmcFlash::Validate(TInt aDeviceType, const TDesC8* /*aInfo*/, const TVersion& aVer)

	{

	OstTraceExt2(TRACE_FLOW, DPHYSICALDEVICEMEDIAMMCFLASH_VALIDATE_ENTRY ,"DPhysicalDeviceMediaMmcFlash::Validate;aDeviceType=%d;this=%x", aDeviceType, (TUint) this);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:validate aDeviceType %d", aDeviceType));

	if (!Kern::QueryVersionSupported(iVersion,aVer))

	    {

		OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_VALIDATE_EXIT1, this, KErrNotSupported );

		return KErrNotSupported;

	    }

	if (aDeviceType!=MEDIA_DEVICE_MMC)

	    {

		OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_VALIDATE_EXIT2, this, KErrNotSupported );

		return KErrNotSupported;

	    }

	OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_VALIDATE_EXIT3, this, KErrNone );

	return KErrNone;

	}

TInt DPhysicalDeviceMediaMmcFlash::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /*aInfo*/, const TVersion& aVer)

//

// Create an MMC Card media driver.

//

	{

	OstTraceExt2(TRACE_FLOW, DPHYSICALDEVICEMEDIAMMCFLASH_CREATE_ENTRY, "DPhysicalDeviceMediaMmcFlash::Create;aMediaId=%d;this=%x", aMediaId, (TUint) this);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:crt"));

	if (!Kern::QueryVersionSupported(iVersion,aVer))

	    {

		OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_CREATE_EXIT1, this, KErrNotSupported );

		return KErrNotSupported;

	    }

	DMmcMediaDriverFlash* pD = new DMmcMediaDriverFlash(aMediaId);

	aChannel=pD;

	TInt r=KErrNoMemory;

	if (pD)

		r=pD->DoCreate(aMediaId);

	if (r==KErrNone)

		pD->OpenMediaDriverComplete(KErrNone);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:mdf"));

	OstTraceFunctionExitExt( DPHYSICALDEVICEMEDIAMMCFLASH_CREATE_EXIT2, this, r );

	return r;

	}

// ======== DMmcMediaDriverFlash ========

void DMmcMediaDriverFlash::Panic(TPanic aPanic)

	{

	_LIT(KPncNm, "MEDMMC");

	Kern::PanicCurrentThread(KPncNm, aPanic);

	}

// ---- accessor functions -----

inline DMMCStack& DMmcMediaDriverFlash::Stack() const

	{ return *static_cast<DMMCStack*>(iStack); }

inline TInt DMmcMediaDriverFlash::CardNum() const

	{ return iCardNumber; }

inline DMmcMediaDriverFlash::TMediaRequest DMmcMediaDriverFlash::CurrentRequest() const

	{ return iMedReq; }

// Helper

template <class T>

inline T* KernAlloc(const TUint32 n)

	{ return static_cast<T*>(Kern::Alloc(n * sizeof(T))); }

// ---- ctor, open, close, dtor ----

#pragma warning( disable : 4355 )	// this used in initializer list

DMmcMediaDriverFlash::DMmcMediaDriverFlash(TInt aMediaId)

   :DMediaDriver(aMediaId),

	iMedReq(EMReqIdle),

    iSessionEndCallBack(DMmcMediaDriverFlash::SessionEndCallBack, this),

	iSessionEndDfc(DMmcMediaDriverFlash::SessionEndDfc, this, 1),

	iMediaId(iPrimaryMedia->iNextMediaId),

    iDataTransferCallBack(DMmcMediaDriverFlash::DataTransferCallBack, this),

	iDataTransferCallBackDfc(DMmcMediaDriverFlash::DataTransferCallBackDfc, this, 1)

	{

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("=mmd:mmd"));

	// NB aMedia Id = the media ID of the primary media, iMediaId = the media ID of this media

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("DMmcMediaDriverFlash(), iMediaId %d, aMediaId %d\n", iMediaId, aMediaId));

	OstTraceExt2( TRACE_FLOW, DMMCMEDIADRIVERFLASH_DMMCMEDIADRIVERFLASH, "> DMmcMediaDriverFlash::DMmcMediaDriverFlash;aMediaId=%d;iMediaId=%d", (TInt) aMediaId, (TInt) iMediaId );

	for(TInt drv = 0; drv < KMaxLocalDrives; drv++)

		{

		SetEMmcPartitionMapping(drv, TExtendedCSD::ESelectUserArea);

		}

	}

#pragma warning( default : 4355 )

TInt DMmcMediaDriverFlash::DoCreate(TInt /*aMediaId*/)

	{

	OstTraceFunctionEntry1( DMMCMEDIADRIVERFLASH_DOCREATE_ENTRY, this );

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:opn"));

	iSocket = ((DMMCSocket*)((DPBusPrimaryMedia*)iPrimaryMedia)->iSocket);

	if(iSocket == NULL)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT1, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	iCardNumber = ((DPBusPrimaryMedia*)iPrimaryMedia)->iSlotNumber;

	iStack = iSocket->Stack(KStackNumber);

	iCard = iStack->CardP(CardNum());

	TMMCMachineInfo machineInfo;

	Stack().MachineInfo(machineInfo);

	TInt slotFlag = iCardNumber == 0 ? TMMCMachineInfo::ESlot1Internal : TMMCMachineInfo::ESlot2Internal;

	iInternalSlot = machineInfo.iFlags & slotFlag;

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("DMmcMediaDriverFlash::DoCreate() slotNumber %d iInternalSlot %d", iCardNumber, iInternalSlot));

	OstTraceExt2(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_SLOT, "slotNumber=%d; iInternalSlot=%d", iCardNumber, iInternalSlot);

	iSessionEndDfc.SetDfcQ(&iSocket->iDfcQ);

	iDataTransferCallBackDfc.SetDfcQ(&iSocket->iDfcQ);

	// check right type of card

	if ((iMediaType=iCard->MediaType())==EMultiMediaNotSupported)	

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT2, this, KErrNotReady );

		return KErrNotReady;

	    }

	// get card characteristics

	const TCSD& csd = iCard->CSD();

	iBlkLenLog2 = iCard->MaxReadBlLen();

	iBlkLen = 1 << iBlkLenLog2;

	iBlkMsk = (TInt64)(iBlkLen - 1);

	SetTotalSizeInBytes(iCard->DeviceSize64());

	//

	// High capcity cards (block addressable, MMCV4.2, SD2.0) do not support partial reads

	// ...some cards incorrectly report that they do, so ensure that we don't

	//

	iReadBlPartial = iCard->IsHighCapacity() ? EFalse : csd.ReadBlPartial();

	// allocate and initialize session object

	TInt r = AllocateSession();

	if (r!= KErrNone)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT3, this, r );

		return r;

	    }

	// get buffer memory from EPBUS

	TUint8* buf;

	TInt bufLen;

	TInt minorBufLen;

	Stack().BufferInfo(buf, bufLen, minorBufLen);

	iMinorBuf = buf;

	// reserve KRpmbOneFramePacketLength bytes after the minor buffer for RPMB requests / responses

	// cache buffer can use rest of blocks in buffer.  Does not have to be power of 2.

	iCacheBuf = iMinorBuf + minorBufLen + KRpmbOneFramePacketLength;

	// We need to devide up the buffer space between the media drivers.

	// The number of buffer sub-areas = number of physical card slots * number of media

	bufLen-= (minorBufLen + KRpmbOneFramePacketLength);

	DPBusPrimaryMedia* primaryMedia = (DPBusPrimaryMedia*) iPrimaryMedia;

	TInt physicalCardSlots = iStack->iMaxCardsInStack;

	TInt numMedia = primaryMedia->iLastMediaId - primaryMedia->iMediaId + 1;

	TInt totalNumMedia = numMedia * physicalCardSlots;

	TInt mediaIndex = iMediaId - primaryMedia->iMediaId;

	TInt bufIndex = (iCardNumber * numMedia)  + mediaIndex;

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("physicalCardSlots %d, iCardNumber %d\n",  physicalCardSlots, iCardNumber));

	OstTraceExt2(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_VARS1, "physicalCardSlots=%d; iCardNumber=%d", physicalCardSlots, iCardNumber);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("iMediaId %d numMedia %d, mediaIndex %d, totalNumMedia %d, bufIndex %d\n", 

			  iMediaId, numMedia, mediaIndex, totalNumMedia, bufIndex));

	OstTraceExt5(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_VARS2, "iMediaId=%d; numMedia=%d; mediaIndex=%d; totalNumMedia=%d; bufIndex=%d", iMediaId, numMedia, mediaIndex, totalNumMedia, bufIndex);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("bufLen1 %08X iCacheBuf1 %08X", bufLen, iCacheBuf));

	OstTraceExt2(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_CACHEBUF1, "bufLen1=0x%08x; iCacheBuf1=0x%08x", (TUint) bufLen, (TUint) iCacheBuf);

	bufLen/= totalNumMedia;

	iCacheBuf+= bufIndex * bufLen;

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("bufLen2 %08X iCacheBuf2 %08X", bufLen, iCacheBuf));

	OstTraceExt2(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_CACHEBUF2, "bufLen2=0x%08x; iCacheBuf2=0x%08x", (TUint) bufLen, (TUint) iCacheBuf);

	iBlocksInBuffer = bufLen >> iBlkLenLog2;	// may lose partial block

	if(iSocket->SupportsDoubleBuffering())

		{

		// Ensure that there's always an even number of buffered blocks when double-buffering

		iBlocksInBuffer &= ~1;

		__ASSERT_DEBUG(iBlocksInBuffer >= 2, Panic(EDBNotEven));

#if defined(_DEBUG)		

		/** 

		 * If Double-Buffering is enabled then the cache should not be greater than the maximum addressable range of the DMA controller,

		 * otherwise Double buffering will never be utilised because all transfers will fit into the cache.

		 */

		const TUint32 maxDbBlocks = iSocket->MaxDataTransferLength() >> iBlkLenLog2;

        if (maxDbBlocks)

            {

            __ASSERT_DEBUG(iBlocksInBuffer <= (TInt)maxDbBlocks, Panic(EDBNotOptimal));

            }

#endif		

		}

	iMaxBufSize = iBlocksInBuffer << iBlkLenLog2;

	iPrWtGpLen = iCard->PreferredWriteGroupLength();

	// check the preferred write group length is a power of two

	if(iPrWtGpLen == 0 || (iPrWtGpLen & (~iPrWtGpLen + 1)) != iPrWtGpLen)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT4, this, KErrNotReady );

		return KErrNotReady;

	    }

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("iMaxBufSize %d iPrWtGpLen %d\n", iMaxBufSize, iPrWtGpLen));

	OstTraceExt2(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_IPRWTGPLEN1, "iMaxBufSize=%d; iPrWtGpLen1=%d", iMaxBufSize, iPrWtGpLen);

	// ensure the preferred write group length is as large as possible

	// so we can write to more than one write group at once

	while (iPrWtGpLen < (TUint32) iMaxBufSize)

		iPrWtGpLen <<= 1;

	// ensure preferred write group length is no greater than internal cache buffer

	while (iPrWtGpLen > (TUint32) iMaxBufSize)

		iPrWtGpLen >>= 1;

	iPrWtGpMsk = TInt64(iPrWtGpLen - 1);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("iPrWtGpLen #2 %d\n", iPrWtGpLen));

	OstTrace1(TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DOCREATE_IPRWTGPLEN2, "iPrWtGpLen2=%d", iPrWtGpLen);

	// allocate index for cached blocks

	iCachedBlocks =	KernAlloc<TInt64>(iBlocksInBuffer);

	if (iCachedBlocks == 0)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT5, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	InvalidateCache();

	iLstUsdCchEnt = iBlocksInBuffer - 1;		// use entry 0 first

	// allocate read lookup index

	iGamma = KernAlloc<TInt>(iBlocksInBuffer);

	if (iGamma == 0)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT6, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	// get current requirements

	iReadCurrentInMilliAmps = csd.MaxReadCurrentInMilliamps();

	iWriteCurrentInMilliAmps = csd.MaxWriteCurrentInMilliamps();

	// get preferred erase information for format operations

	const TInt err = iCard->GetEraseInfo(iEraseInfo);

	if(err != KErrNone)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT7, this, err );

		return err;

	    }

	iEraseUnitMsk = TInt64(iEraseInfo.iPreferredEraseUnitSize) - 1;

	// Retrieve the demand paging info from the PSL of the stack

	Stack().DemandPagingInfo(iDemandPagingInfo);

	// if a password has been supplied then it is sent when the partition info is read

	//

	// If this is an internal slot, then use the eMMC partition function

	//

	if(iInternalSlot)

		{

		iMmcPartitionInfo = CreateEmmcPartitionInfo();

		if(iMmcPartitionInfo == NULL)

		    {

			OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT8, this, KErrNoMemory );

			return KErrNoMemory;

		    }

		TInt err = iMmcPartitionInfo->Initialise(this);

		if(err != KErrNone)

		    {

			OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT9, this, err );

			return err;

		    }

		}

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:opn"));

	OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOCREATE_EXIT10, this, KErrNone );

	return KErrNone;

	}

void DMmcMediaDriverFlash::Close()

//

// Close the media driver - also called on media change

//

	{

	OstTraceFunctionEntry0( DMMCMEDIADRIVERFLASH_CLOSE_ENTRY );

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("=mmd:cls"));

	EndInCritical();

	iSessionEndDfc.Cancel();

	iDataTransferCallBackDfc.Cancel();

	CompleteRequest(KErrNotReady);

	DMediaDriver::Close();

	OstTraceFunctionExit0( DMMCMEDIADRIVERFLASH_CLOSE_EXIT );

	}

DMmcMediaDriverFlash::~DMmcMediaDriverFlash()

	{

	OstTraceFunctionEntry0( DMMCMEDIADRIVERFLASH_DMMCMEDIADRIVERFLASH_ENTRY );

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:dtr"));

	iSessionEndDfc.Cancel();

	iDataTransferCallBackDfc.Cancel();

	delete iSession;

	Kern::Free(iCachedBlocks);

	Kern::Free(iGamma);

	delete iMmcPartitionInfo;

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:dtr"));

	OstTraceFunctionExit0( DMMCMEDIADRIVERFLASH_DMMCMEDIADRIVERFLASH_EXIT );

	}

TInt DMmcMediaDriverFlash::AllocateSession()

	{

OstTraceFunctionEntry1( DMMCMEDIADRIVERFLASH_ALLOCATESESSION_ENTRY, this );

	// already allocated ?

	if (iSession != NULL)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_ALLOCATESESSION_EXIT1, this, KErrNone );

		return KErrNone;

	    }

	iSession = iStack->AllocSession(iSessionEndCallBack);

	if (iSession == NULL)

	    {

		OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_ALLOCATESESSION_EXIT2, this, KErrNoMemory );

		return KErrNoMemory;

	    }

	iSession->SetStack(iStack);

	iSession->SetCard(iCard);

	iSession->SetDataTransferCallback(iDataTransferCallBack);