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

// 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

// 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

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);

GLREF_C TInt GetCardFormatInfo(const TMMCard* aCardP, TLDFormatInfo& aFormatInfo);

const TInt KStackNumber = 0;

const TInt KDiskSectorSize=512;

const TInt KDiskSectorShift=9;

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;

class DMmcMediaDriverFlash : public DMediaDriver

	{

public:

	DMmcMediaDriverFlash(TInt aMediaId);

	~DMmcMediaDriverFlash();

	// ...from DMediaDriver

	virtual void Close();

	// replacing pure virtual

	virtual void Disconnect(DLocalDrive* aLocalDrive, TThreadMessage*);

	virtual TInt Request(TLocDrvRequest& aRequest);

	virtual TInt PartitionInfo(TPartitionInfo& anInfo);

	virtual void NotifyPowerDown();

	virtual void NotifyEmergencyPowerDown();

	// For creation by DPhysicalDeviceMediaMmcFlash

	TInt DoCreate(TInt aMediaId);

private:

	enum TPanic

		{

		EDRInUse		= 0x0000,	EDRStart, EDRNotPositive, EDREnd,

		ELRRequest		= 0x0010,	ELRStart, ELRNotPositive, ELREnd, ELRCached,

		EDWInUse		= 0x0020,	EDWStart, EDWNotPositive, EDWEnd,

		EDFInUse		= 0x0030,	EDFStart, EDFNotPositive, EDFEnd, ENotMmcSocket,

		ELWRequest		= 0x0040,	ELWStart, ELWFmtStAlign, ELWNotPositive, ELWEnd, ELWFmtEndAlign, 

									ELWLength, ELFStart, ELFEnd, ELFNotPositive,

		ERPIInUse		= 0x0050,

		EPCInUse		= 0x0060,	EPCFunc,

		ESECBQueued		= 0x0070,

		EDSEDRequest	= 0x0080,	EDSEDNotErrComplete,

		ECRReqIdle		= 0x0090,	ECRRequest,

		ERRBStAlign		= 0x00a0,	ERRBStPos, ERRBNotPositive, ERRBEndAlign, ERRBEndPos,

									ERRBOverflow, ERRBCchInv, ERRBExist,

		ERWBStPos		= 0x00b0,	ERWBNotPositive, ERWBEndPos, ERWBOverflow, ERWBCchInv,

		EMBStPos		= 0x00c0,	EMBStAlign, EMBNotPositive, EMBEndPos, EMBEndAlign,

									EMBOverflow, EMBCchInvPre, EMBCchInvPost,

		EBGAStPos		= 0x00d0,	EBGAStAlign, EBGANotPositive, EBGAEndPos, EBGAEndAlign,

									EBGAOverflow, EBGACchInv,

		EICMNegative	= 0x00e0,	EICMOverflow, ECMIOverflow,

		EGCBAlign		= 0x00f0,	EGCBPos, EGCBCchInv,

		ECFSessPtrNull	= 0x0100,	// Code Fault - session pointer NULL

		EDBNotEven		= 0x0110,	// Not and even number of blocks in the buffer cache

		EDBCBQueued		= 0x0111,	// The data transfer callback is already queued

		EDBLength		= 0x0112,	// The length of data to transfer in data transfer callback is not positive

		EDBLengthTooBig	= 0x0113,	// The length of data to transfer in data transfer callback is too big

		EDBOffsetTooBig = 0x0114,	// The Offset into the user data buffer is too big

		EDBCacheInvalid	= 0x0115,	// The cache is invalid at the end of data transfer

		EDBNotOptimal	= 0x0116,	// Due to Cache size DB functionality will never be utilised

		ENoDBSupport	= 0x0120,	// DMA request arrived but PSL does not support double buffering

		ENotDMAAligned  = 0x0121,

		};

	static void Panic(TPanic aPnc);

	enum TMediaRequest

		{

		EMReqRead = 0,

		EMReqWrite = 1,

		EMReqFormat = 2,

		EMReqPtnInfo,

		EMReqPswdCtrl,

		EMReqForceErase,

		EMReqUpdatePtnInfo,

		EMReqWritePasswordData,

		EMReqIdle,

		EMReqEMMCPtnInfo,

		};

	enum TMediaReqType {EMReqTypeNormalRd,EMReqTypeNormalWr,EMReqTypeUnlockPswd,EMReqTypeChangePswd};

	enum {KWtRBMFst = 0x00000001, 	// iWtRBM - Read First Block only

		  KWtRBMLst = 0x00000002,	// iWtRBM - Read Last Block only

		  KWtMinFst = 0x00000004,	// iWtRBM - Write First Block only

		  KWtMinLst = 0x00000008,	// iWtRBM - Write Last Block only

		  KIPCSetup = 0x00000010,	// iRdROB - IPC Setup Next Iteration

		  KIPCWrite = 0x00000020};	// iRdROB - IPC Write Next Iteration

private:

	// MMC device specific stuff

	TInt DoRead();

	TInt DoWrite();

	TInt DoFormat();

	TInt Caps(TLocDrv& aDrive, TLocalDriveCapsV6& aInfo);

	inline DMMCStack& Stack() const;

	inline TInt CardNum() const;

	inline TMediaRequest CurrentRequest() const;

	TInt LaunchRead(TInt64 aStart, TUint32 aLength);

	TInt LaunchDBRead();

	TInt LaunchPhysRead(TInt64 aStart, TUint32 aLength);

	TInt LaunchWrite(TInt64 aStart, TUint32 aLength, TMediaRequest aMedReq);

	TInt LaunchFormat(TInt64 aStart, TUint32 aLength);

	TInt LaunchRPIUnlock(TLocalDrivePasswordData& aData);

	TInt LaunchRPIRead();

	TInt LaunchRPIErase();

	TInt DecodePartitionInfo();

	TInt WritePartitionInfo();

	TInt GetDefaultPartitionInfo(TMBRPartitionEntry& aPartitionEntry);

	TInt CreateDefaultPartition();

#if defined __TEST_PAGING_MEDIA_DRIVER__

	TInt HandleControlIORequest();

#endif

	static void SetPartitionEntry(TPartitionEntry* aEntry, TUint aFirstSector, TUint aNumSectors);

	TInt CheckDevice(TMediaReqType aReqType);

	static void SessionEndCallBack(TAny* aMediaDriver);

	static void SessionEndDfc(TAny* aMediaDriver);

	void DoSessionEndDfc();

	static void DataTransferCallBack(TAny* aMediaDriver);

	static void DataTransferCallBackDfc(TAny* aMediaDriver);

	void DoReadDataTransferCallBack();

	void DoWriteDataTransferCallBack();

	void DoPhysReadDataTransferCallBack();

	void DoPhysWriteDataTransferCallBack();

	TInt AdjustPhysicalFragment(TPhysAddr &physAddr, TInt &physLength);

	TInt PrepareFirstPhysicalFragment(TPhysAddr &aPhysAddr, TInt &aPhysLength, TUint32 aLength);

	void PrepareNextPhysicalFragment();

	TInt EngageAndSetReadRequest(TMediaRequest aRequest);

	TInt EngageAndSetWriteRequest(TMediaRequest aRequest);

	TInt EngageAndSetRequest(TMediaRequest aRequest, TInt aCurrent);

	void CompleteRequest(TInt aReason);

	TInt ReadDataUntilCacheExhausted(TBool* aAllDone);

	TInt WriteDataToUser(TUint8* aBufPtr);

	TInt ReadDataFromUser(TDes8& aDes, TInt aOffset);

	TUint8* ReserveReadBlocks(TInt64 aStart, TInt64 aEnd, TUint32* aLength);

	TUint8* ReserveWriteBlocks(TInt64 aMedStart, TInt64 aMedEnd, TUint* aRBM);

	void MarkBlocks(TInt64 aStart, TInt64 aEnd, TInt aStartIndex);

	void BuildGammaArray(TInt64 aStart, TInt64 aEnd);

	void InvalidateCache();

	void InvalidateCache(TInt64 aStart, TInt64 aEnd);

	TUint8* IdxToCchMem(TInt aIdx) const;

	TInt CchMemToIdx(TUint8* aMemP) const;

	TInt DoPasswordOp();

	void PasswordControl(TInt aFunc, TLocalDrivePasswordData& aData);

	void Reset();

	TInt AllocateSession();  

#ifdef _DEBUG_CACHE

	TBool CacheInvariant();

	TUint8* GetCachedBlock(TInt64 aAddr);

#endif

private:

	DMMCStack* iStack;			 				// controller objects

	TMMCard* iCard;

	DMMCSession* iSession;

	DMMCSocket* iSocket;

	TInt iCardNumber;

	TUint iBlkLenLog2;							// cached CSD data

	TUint32 iBlkLen;

	TInt64 iBlkMsk;

	TBool iReadBlPartial;

	TUint32 iPrWtGpLen;							// preferred write group size in bytes,

	TInt64 iPrWtGpMsk;

	TInt iReadCurrentInMilliAmps;				// power management

	TInt iWriteCurrentInMilliAmps;

	TUint8* iMinorBuf;							// MBR, CMD42, partial read

	TUint8* iCacheBuf;							// cached buffer

	TUint32 iMaxBufSize;

	TInt iBlocksInBuffer;

	TInt64* iCachedBlocks;

	TInt* iGamma;								// B lookup, ReserveReadBlocks()

	TUint8* iIntBuf;							// start of current buffer region

	TInt iLstUsdCchEnt;							// index of last used cache entry

	TLocDrvRequest* iCurrentReq;				// Current Request

	TMediaRequest iMedReq;

	TInt64 iReqStart;							// user-requested start region

	TInt64 iReqCur;								// Currently requested start region

	TInt64 iReqEnd;							    // user-requested end region

	TInt64 iPhysStart;							// physical region for one operation

	TInt64 iPhysEnd;						    // physical end point for one operation

	TInt64 iDbEnd;								// Double buffer end point for one operation

	TUint64 iEraseUnitMsk;

	TUint iWtRBM;								// Write - Read Before Modify Flags

	TUint iRdROB;								// Read  - Read Odd Blocks Flags

	TInt iFragOfset;			

	TUint32 iIPCLen;

	TUint32 iNxtIPCLen;

	TUint32 iBufOfset;

	TUint iHiddenSectors;						// bootup / password

	TMMCCallBack iSessionEndCallBack;

	TDfc iSessionEndDfc;

	TPartitionInfo* iPartitionInfo;

	TMMCMediaTypeEnum iMediaType;

	TMMCEraseInfo iEraseInfo;

	TBool iMbrMissing;

	TInt iMediaId;

	DMMCStack::TDemandPagingInfo iDemandPagingInfo;

#if defined(__TEST_PAGING_MEDIA_DRIVER__)

	SMmcStats iMmcStats;

#endif // __TEST_PAGING_MEDIA_DRIVER__

	TMMCCallBack iDataTransferCallBack;	// Callback registered with the MMC stack to perform double-buffering

	TDfc iDataTransferCallBackDfc;		// ...and the associated DFC queue.

	TBool iSecondBuffer;				// Specified the currently active buffer

	TBool iDoLastRMW;					// ETrue if the last double-buffer transfer requires RMW modification

	TBool iDoDoubleBuffer;				// ETrue if double-buffering is currently active

	TBool iDoPhysicalAddress;			// ETrue if Physical Addressing is currently active

	TBool iCreateMbr;

	TBool iReadToEndOfCard;				// {Read Only} ETrue if Reading to end of Card

	TBool iInternalSlot;

	DEMMCPartitionInfo* iMmcPartitionInfo;  // Responsible for decoding partitions for embedded devices

	};

// ======== 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 );

	}

#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;

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

	iCacheBuf = iMinorBuf + minorBufLen;

	// 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;

	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);

	OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_ALLOCATESESSION_EXIT3, this, KErrNone );

	return KErrNone;

	}

// ---- media access ----

TInt DMmcMediaDriverFlash::DoRead()

//

// set up iReqStart, iReqEnd and iReqCur and launch first read.  Subsequent reads

// will be launched from the callback DFC.

//

	{

	OstTraceFunctionEntry1( DMMCMEDIADRIVERFLASH_DOREAD_ENTRY, this );

	TInt r = CheckDevice(EMReqTypeNormalRd); 

	if (r != KErrNone)

	    {

	    OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOREAD_EXIT1, this, r );

	    return r;

	    }

	const TInt64 pos(iCurrentReq->Pos());

	TUint32 length(I64LOW(iCurrentReq->Length()));

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:dr:0x%lx,0x%x", pos, length));

	OstTraceExt2( TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_DO_READ, "Position=0x%lx; Length=0x%x", (TUint) pos, (TUint) length);

	__ASSERT_DEBUG(CurrentRequest() == EMReqIdle, Panic(EDRInUse));

	__ASSERT_DEBUG(pos < TotalSizeInBytes(), Panic(EDRStart));

	__ASSERT_DEBUG(iCurrentReq->Length() >= 0, Panic(EDRNotPositive));

	__ASSERT_DEBUG(TotalSizeInBytes() >= pos + length, Panic(EDREnd));

	if(length > 0)

		{

		iReqCur = iReqStart = pos;

		iReqEnd = iReqStart + length;

		TBool allDone(EFalse);

		if ( ((r = ReadDataUntilCacheExhausted(&allDone)) == KErrNone) && !allDone)

			{

			iMedReq = EMReqRead;

			iPhysStart = iReqCur & ~iBlkMsk;

			__ASSERT_DEBUG(I64HIGH(iPhysStart >> KMMCardHighCapBlockSizeLog2) == 0, Panic(ELRStart));

			iReadToEndOfCard = ( iReqEnd >= TotalSizeInBytes() );

			// Re-calculate length as some data may have been recovered from cache

			length = I64LOW(iReqEnd - iReqCur);

			if (iCurrentReq->IsPhysicalAddress() && !iReadToEndOfCard && (length >= iBlkLen) )

				r = LaunchPhysRead(iReqCur, length);

			else if ( (iReqEnd - iPhysStart) > iMaxBufSize && iSocket->SupportsDoubleBuffering() && !iReadToEndOfCard)

				r = LaunchDBRead();

			else

				r = LaunchRead(iReqCur, length);

			if (r == KErrNone)

			    {

			    OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOREAD_EXIT2, this, r );

			    return r;

			    }

			}

		}

	else

		{

#if defined(__DEMAND_PAGING__) && !defined(__WINS__)

		if (DMediaPagingDevice::PageInRequest(*iCurrentReq))

			{

			r = iCurrentReq->WriteToPageHandler(NULL, 0, 0);

			}

		else

#endif	// __DEMAND_PAGING__

			{

			TPtrC8 zeroDes(NULL, 0);

			r = iCurrentReq->WriteRemote(&zeroDes,0);

			}

		}

	// error occurred or read all from cache so complete immediately

	if(r == KErrNone)

		r = KErrCompletion;

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:dr:%d", r));

	OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_DOREAD_EXIT3, this, r );

	return r;

	}

TInt DMmcMediaDriverFlash::LaunchRead(TInt64 aStart, TUint32 aLength)

//

// starts reads from DoRead() and the session end DFC.  This function does not maintain the

// iReq* instance variables.  It sets iPhysStart and iPhysEnd to the region that was actually

// read into iIntBuf. iIntBuf can be set to a cached entry or to the minor buffer.  It is

// assumed that before this function is called that ReadDataUntilCacheExhausted() has been used.

//

	{

	OstTraceFunctionEntryExt( DMMCMEDIADRIVERFLASH_LAUNCHREAD_ENTRY, this );

	OstTraceExt2( TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_LAUNCHREAD, "position=0x%lx; length=0x%x", (TUint) iCurrentReq->Pos(), (TUint) I64LOW(iCurrentReq->Length()));

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:lr:0x%lx,0x%x", aStart, aLength));

	__ASSERT_DEBUG(TotalSizeInBytes() > aStart, Panic(ELRStart));

	__ASSERT_DEBUG(aLength > 0, Panic(ELRNotPositive));

	__ASSERT_DEBUG(TotalSizeInBytes() >= aStart + aLength, Panic(ELREnd));

	__ASSERT_CACHE(GetCachedBlock(aStart & ~iBlkMsk) == 0, Panic(ELRCached));

	__ASSERT_DEBUG(iSession != NULL, Panic(ECFSessPtrNull));

	iDoPhysicalAddress = EFalse;

	iDoDoubleBuffer = EFalse;

	iSecondBuffer = EFalse;

	// 

	// if this read goes up to the end of the card then use only 

	// single sector reads to avoid CMD12 timing problems

	//

	const TUint32 bufSize(iReadToEndOfCard ? iBlkLen : iMaxBufSize);

	iPhysEnd = (UMin(iReqEnd, iPhysStart + bufSize) + iBlkMsk) & ~iBlkMsk;

	TUint32 physLen(I64LOW(iPhysEnd - iPhysStart));

	__ASSERT_DEBUG(I64HIGH(iPhysEnd - iPhysStart) == 0, Panic(ELREnd));

	// partial reads must be within a single physical block

	if (iReadBlPartial && physLen == iBlkLen && aLength <= (iBlkLen >> 1))

		{

		// 

		// Note : Partial reads are not supported for large block devices 

		//        (MMCV4.2 and SD2.0 high capacity cards)

		//

		__ASSERT_DEBUG(I64HIGH(aStart) == 0, Panic(ELRStart));

		__ASSERT_DEBUG(I64HIGH(aStart + aLength) == 0, Panic(ELREnd));

		iIntBuf = iMinorBuf;

		Stack().AdjustPartialRead(iCard, I64LOW(aStart), I64LOW(aStart + aLength), (TUint32*)&iPhysStart, (TUint32*)&iPhysEnd);

		iSession->SetupCIMReadBlock(I64LOW(iPhysStart >> KMMCardHighCapBlockSizeLog2), iIntBuf, physLen >> KMMCardHighCapBlockSizeLog2);

		}

	else

		{	

		iIntBuf = ReserveReadBlocks(iPhysStart, iPhysEnd, &physLen);

		// EPBUSM automatically uses CMD17 instead of CMD18 for single block reads

		iSession->SetupCIMReadBlock(I64LOW(iPhysStart >> KMMCardHighCapBlockSizeLog2), iIntBuf, physLen >> KMMCardHighCapBlockSizeLog2);

		// Update Physical end point as less may have been required due to additional blocks found in cache during ReserveReadBlocks

		iPhysEnd = iPhysStart + physLen;

		}

	TInt r = EngageAndSetReadRequest(EMReqRead);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:lr:%d", r));

	OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_LAUNCHREAD_EXIT, this, r );

	return r;

	}

TInt DMmcMediaDriverFlash::LaunchDBRead()

//

// starts reads from DoRead() and the session end DFC.  This function does not maintain the

// iReq* instance variables.  It sets iPhysStart and iPhysEnd to the region that was actually

// read into iIntBuf. iIntBuf can be set to a cached entry or to the minor buffer.  It is

// assumed that before this function is called that ReadDataUntilCacheExhausted() has been used.

//

	{

	OstTraceFunctionEntry1( DMMCMEDIADRIVERFLASH_LAUNCHDBREAD_ENTRY, this );

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:ldbr:0x%lx,0x%x", iReqCur, I64LOW(iReqEnd - iReqCur)));

	OstTraceExt2( TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_LAUNCHDBREAD, "position=0x%lx; length=0x%x", (TInt) iReqCur, (TInt) I64LOW(iReqEnd - iReqCur));

	__ASSERT_DEBUG(TotalSizeInBytes() > iReqCur, Panic(ELRStart));

	__ASSERT_DEBUG(I64LOW(iReqEnd - iReqCur) > 0, Panic(ELRNotPositive));

	__ASSERT_DEBUG(TotalSizeInBytes() >= iReqEnd, Panic(ELREnd));

	__ASSERT_CACHE(GetCachedBlock(iReqCur & ~iBlkMsk) == 0, Panic(ELRCached));

	__ASSERT_DEBUG(iSession != NULL, Panic(ECFSessPtrNull));

	iDoDoubleBuffer = ETrue;

	iDoPhysicalAddress = EFalse;

	iDbEnd = iReqEnd;

	const TUint32 maxDbLength = iSocket->MaxDataTransferLength();

	if(maxDbLength)

		{

		//

		// If the PSL specifies a limit on the maximum size of a data transfer, then truncate the request...

		//

		iDbEnd = UMin(iDbEnd, iPhysStart + maxDbLength);

		}

	iDbEnd = (iDbEnd + iBlkMsk) & ~iBlkMsk;

	const TUint32 doubleBufferSize = iMaxBufSize >> 1;

	iPhysEnd = (iReqCur + doubleBufferSize) & ~iBlkMsk;	// The end of the first double-buffered transfer

	//

	// If we're double-buffering, then the entire cache will be re-used

	// continuously.  Rather than continually reserve blocks during each 

	// transfer we calculate the blocks that will be present after all

	// transfers have completed. 

	// @see DoSessionEndDfc()

	//

	InvalidateCache();

	iIntBuf = iCacheBuf;

	iSession->SetupCIMReadBlock(I64LOW(iPhysStart >> KMMCardHighCapBlockSizeLog2), iIntBuf, I64LOW(iDbEnd - iPhysStart) >> KMMCardHighCapBlockSizeLog2);

	iSession->EnableDoubleBuffering(doubleBufferSize >> KDiskSectorShift);

	// ...and switch to the 'second' buffer, which will be populated in the

	// data transfer callback in parallel with hardware transfer of the first.

	iSecondBuffer = ETrue;

	TInt r = EngageAndSetReadRequest(EMReqRead);

	__KTRACE_OPT(KPBUSDRV, Kern::Printf("<mmd:ldbr:%d", r));

	OstTraceFunctionExitExt( DMMCMEDIADRIVERFLASH_LAUNCHDBREAD_EXIT, this, r );

	return r;

	}

TInt DMmcMediaDriverFlash::LaunchPhysRead(TInt64 aStart, TUint32 aLength)

//

// This function does not maintain the iReq* instance variables.  

// It is assumed that before this function is called that 

// ReadDataUntilCacheExhausted() has been used.

//

	{

	OstTraceFunctionEntryExt( DMMCMEDIADRIVERFLASH_LAUNCHPHYSREAD_ENTRY, this );

	OstTraceExt2( TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_LAUNCHPHYSREAD, "position=0x%lx; length=0x%x", (TInt) iReqCur, (TInt) I64LOW(iReqEnd - iReqCur));

	__KTRACE_OPT(KPBUSDRV, Kern::Printf(">mmd:physr:0x%lx,0x%x", aStart, aLength));

	__ASSERT_DEBUG(TotalSizeInBytes() > aStart, Panic(ELRStart));

	__ASSERT_DEBUG(aLength > 0, Panic(ELRNotPositive));

	__ASSERT_DEBUG(TotalSizeInBytes() >= aStart + aLength, Panic(ELREnd));

	__ASSERT_CACHE(GetCachedBlock(aStart & ~iBlkMsk) == 0, Panic(ELRCached));

	__ASSERT_DEBUG(iSession != NULL, Panic(ECFSessPtrNull));

	TInt r(KErrNone);

	iDoPhysicalAddress = ETrue;  

	iDoDoubleBuffer = EFalse;

	// Local Media Subsystem ensures DMA Addressable range not exceeded.

	// @see LocDrv::RegisterDmaDevice()

	iPhysEnd = (iReqEnd + iBlkMsk) & ~iBlkMsk;

	iRdROB = 0;

	iFragOfset = iIPCLen = iNxtIPCLen = iBufOfset = 0; 

	// Determine if start/end are block aligned

	// physical memory can only read the exact amount, not more!

	const TBool firstPartial( (aStart & iBlkMsk) != 0);

	TPhysAddr physAddr(0);						

	TInt physLength(0);

	TUint32 physLen(I64LOW(iPhysEnd - iPhysStart));

	if (firstPartial)

		{

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

		OstTrace0( TRACE_INTERNALS, DMMCMEDIADRIVERFLASH_LAUNCH_PHYSREAD_FP, "FirstPartial");

		// first index does not start on block boundary

		// iIntBuf linear address is used for IPC within DoReadDataTransferCallBack()

		iRdROB |= KIPCWrite;