// Copyright (c) 1998-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\locmedia.cpp
// 
//

#include "locmedia.h"
#include <d32locd.h>
#include "dmasupport.h"
#include <kernel/cache.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 "locmediaTraces.h"
#endif

#if defined(_DEBUG) && defined(__DEMAND_PAGING__)
//#define __DEBUG_DEMAND_PAGING__
#endif


#if 0
#define CHECK_RET(r)	if ((r)==KErrNotSupported && (KDebugNum(KSCRATCH))) {NKern::Lock(); *(TInt*)0xfaece5=0;}
//#define CHECK_RET(r)
#else
#define CHECK_RET(r)
#endif

_LIT(KLddName,"LocDrv");
_LIT(KLitMediaDriverName, "Media.*");
_LIT(KLitLocMedia,"LocMedia");

#define LOCM_FAULT()	Kern::Fault("LOCMEDIA",__LINE__)

const TInt KMaxLocalDriveCapsLength=256;
const TInt KMaxQueryDeviceLength=256;

// The maximum amount of user-data which will be pinned. If a request is longer 
// than this value it will be split up into a number of requests
// This value is a bit arbitrary - it needs to be sufficiently large so that transfer 
// rates don't suffer too much - but it can't be too big or we'd be "stealing" too much 
// memory from the demand paging pool and starving other processes
const TInt KMaxPinData = 256*1024;

// The number of locks available for pinning shared by all the drive threads in the system. 
// If all locks are in use then a single pre-allocated lock is used.
const TInt KDynamicPagingLockCount = 8;

TLocDrv* TheDrives[KMaxLocalDrives];
DMedia* TheMedia[KMaxLocalDrives];
HBuf* DriveNames[KMaxLocalDrives];
TInt UsedMedia=0;
TPasswordStore* ThePasswordStore=NULL;

class DPrimaryMediaBase::DBody : public DBase
	{
public:
	DBody(DPrimaryMediaBase& aPrimaryMediaBase);
public:
	DPrimaryMediaBase& iPrimaryMediaBase;	// ptr to parent
	TInt iPhysDevIndex;
	TInt iRequestCount;
#ifdef __DEMAND_PAGING__
	DMediaPagingDevice* iPagingDevice;
	TInt iPageSizeMsk;			// Mask of page size (e.g. 4096-1 -> 4095)
	TInt iPageSizeLog2;        // LOG2 of page size (i.e. 4096 -> 12)
	TInt iMediaChanges;
#endif

	// This bit mask indicates which local drives the media is attached to
	TUint32 iRegisteredDriveMask;

	// Set to ETrue for media extension drivers
	TBool iMediaExtension;
	
	// Media change DFCs to allow media change events from attached media
	// to be handled in the context of an extension media's thread
	TDfc iMediaChangeDfc;
	TDfc iMediaPresentDfc;
	};

#ifdef __DEMAND_PAGING__
DMediaPagingDevice* ThePagingDevices[KMaxLocalDrives];
DPrimaryMediaBase* TheRomPagingMedia = NULL;
DPrimaryMediaBase* TheDataPagingMedia = NULL;
TLocDrv* TheDataPagingDrive = NULL;
TBool DataPagingDeviceRegistered = EFalse;
class DPinObjectAllocator;
DPinObjectAllocator* ThePinObjectAllocator = NULL;

// The paging media might share a DfcQ with other non-paging media (e.g. 2 MMC/SD cards sharing the same stack)
// In this case, we need to avoid taking page faults on the non-paging media too, hence the need for these checks:
inline TBool DataPagingDfcQ(DPrimaryMediaBase* aPrimaryMedia)
	{return TheDataPagingMedia && TheDataPagingMedia->iDfcQ == aPrimaryMedia->iDfcQ;}


TBool DataPagingMedia(DPrimaryMediaBase* aPrimaryMedia)
	{
	for (TLocDrv* drv = TheDataPagingDrive; drv; drv = drv->iNextDrive)
		if (drv->iPrimaryMedia == aPrimaryMedia)
			return ETrue;
	return EFalse;
	}

inline TBool RomPagingDfcQ(DPrimaryMediaBase* aPrimaryMedia)
	{return TheRomPagingMedia && TheRomPagingMedia->iDfcQ == aPrimaryMedia->iDfcQ;}


#if defined(_DEBUG)
	#define SETDEBUGFLAG(aBitNum) {Kern::SuperPage().iDebugMask[aBitNum >> 5] |= (1 << (aBitNum & 31));}
	#define CLRDEBUGFLAG(aBitNum) {Kern::SuperPage().iDebugMask[aBitNum >> 5] &= ~(1 << (aBitNum & 31));}
#else
	#define SETDEBUGFLAG(aBitNum)
	#define CLRDEBUGFLAG(aBitNum)
#endif



/* 
DPinObjectAllocator

Internal class which contains :
	(1) a queue of pre-allocated TVirtualPinObject's; 
	(2) a single pre-allocated DFragmentationPagingLock object: 
		this may be used if there are no TVirtualPinObject's available or if Kern::PinVirtualMemory() fails
@internalTechnology
*/
NONSHARABLE_CLASS(DPinObjectAllocator) : public DBase
	{
public:
	/*
	SVirtualPinContainer
	Internal class encapsulating a TVirtualPinObject.
	Contains a SDblQueLink so that it may form part of a SDblQue
	*/
	typedef struct
		{
		TVirtualPinObject* iObject;
		SDblQueLink iLink;
		} SVirtualPinContainer;

public:
	inline DPinObjectAllocator() {};
	~DPinObjectAllocator();
	TInt Construct(TInt aObjectCount, TUint aNumPages);
	
	SVirtualPinContainer* AcquirePinObject();
	void ReleasePinObject(SVirtualPinContainer* aVirtualPinObject);

	inline DFragmentationPagingLock& PreAllocatedDataLock() {return *iPreAllocatedDataLock;}

private:
	// array of SVirtualPinContainer's
	SVirtualPinContainer* iVirtualPinContainers;
	TInt iObjectCount;

	// queues containing SVirtualPinContainer's
	SDblQue iFreeQ;
	
	// pre-allocated (small) buffers for locking client data should Kern::PinVirtualMemory() fail
	DFragmentationPagingLock* iPreAllocatedDataLock;

	// A mutex to protect access to the pinning objects.
	NFastMutex iLock;

public:
	TUint iFragmentGranularity;
	};


DPinObjectAllocator::~DPinObjectAllocator()
	{
	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_ENTRY, this );
	if (iPreAllocatedDataLock)
		{
		iPreAllocatedDataLock->Cleanup();
		delete iPreAllocatedDataLock;
		}

	for (TInt n=0; iVirtualPinContainers!= NULL && n<iObjectCount; n++)
		{
		SVirtualPinContainer& virtualPinContainer = iVirtualPinContainers[n];
		if (virtualPinContainer.iObject)
			Kern::DestroyVirtualPinObject(virtualPinContainer.iObject);
		}

	delete [] iVirtualPinContainers;
	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_DPINOBJECTALLOCATOR_EXIT, this );
	}

TInt DPinObjectAllocator::Construct(TInt aObjectCount, TUint aNumPages)
	{
	OstTraceFunctionEntryExt( DPINOBJECTALLOCATOR_CONSTRUCT_ENTRY, this );
	TInt pageSize = Kern::RoundToPageSize(1);
	iFragmentGranularity = pageSize * aNumPages;
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));
	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPINOBJECTALLOCATOR_CONSTRUCT, "Fragmentation granularity=0x%x", iFragmentGranularity);
	
	// construct the paging lock containing pre-allocated buffers

	iPreAllocatedDataLock = new DFragmentationPagingLock();
	if(!iPreAllocatedDataLock)
	    {
		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT1, this, KErrNoMemory );
		return KErrNoMemory;
	    }
	TInt r = iPreAllocatedDataLock->Construct(aNumPages);
	if (r != KErrNone)
	    {
		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT2, this, r );
		return r;
	    }


	iVirtualPinContainers = new SVirtualPinContainer[aObjectCount];
	if (iVirtualPinContainers == NULL)
	    {
		OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT3, this, KErrNoMemory );
		return KErrNoMemory;
	    }
	memclr(iVirtualPinContainers, sizeof(SVirtualPinContainer) * aObjectCount);
	iObjectCount = aObjectCount;

	// construct the queue of dynamic paging locks
	for (TInt n=0; n<aObjectCount; n++)
		{
		SVirtualPinContainer& pinContainer = iVirtualPinContainers[n];

		TInt r = Kern::CreateVirtualPinObject(pinContainer.iObject);
		if (r != KErrNone)
		    {
			OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT4, this, KErrNoMemory );
			return KErrNoMemory;
		    }

		iFreeQ.Add(&pinContainer.iLink);
		}
	
	OstTraceFunctionExitExt( DPINOBJECTALLOCATOR_CONSTRUCT_EXIT5, this, KErrNone );
	return KErrNone;
	}

/** 
returns a SVirtualPinContainer object or NULL if NULL available
*/
DPinObjectAllocator::SVirtualPinContainer* DPinObjectAllocator::AcquirePinObject()
	{
	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_ENTRY, this );
	SVirtualPinContainer* pinContainer = NULL;
	
	NKern::FMWait(&iLock);

	if (!iFreeQ.IsEmpty())
		{
		SDblQueLink* link = iFreeQ.First();
		pinContainer = _LOFF(link, SVirtualPinContainer, iLink);
		link->Deque();
		}


	NKern::FMSignal(&iLock);
	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_ACQUIREPINOBJECT_EXIT, this );
	return pinContainer;
	}

/** 
returns a SVirtualPinContainer object to the pool
*/
void DPinObjectAllocator::ReleasePinObject(SVirtualPinContainer* aPinContainer)
	{
	OstTraceFunctionEntry1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_ENTRY, this );
	NKern::FMWait(&iLock);

	iFreeQ.Add(&aPinContainer->iLink);

	NKern::FMSignal(&iLock);
	OstTraceFunctionExit1( DPINOBJECTALLOCATOR_RELEASEPINOBJECT_EXIT, this );
	}

#endif	// __DEMAND_PAGING__


/* 
TDriveIterator

Internal class which supports iterating through all local drives (TLocDrv's)
If there are media extensions present, then this will iterate through all attached drives.
@internalTechnology
*/
class TDriveIterator
	{
public:
	TDriveIterator();
	TLocDrv* NextDrive();
	inline TInt Index()
		{return iIndex;}
	static TLocDrv* GetDrive(TInt aDriveNum, DPrimaryMediaBase* aPrimaryMedia);
	static TLocDrv* GetPhysicalDrive(TLocDrv* aDrv);

#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)
	static DMediaPagingDevice* PagingDevice(TInt aDriveNum, DPagingDevice::TType aType);
#endif

private:
	TInt iIndex;
	TLocDrv* iDrive;
	};

TDriveIterator::TDriveIterator() :
	iIndex(0), iDrive(NULL)
	{
	}

TLocDrv* TDriveIterator::NextDrive()
	{
	if (iDrive)	// i.e. if not first time
		{
		if (iDrive->iNextDrive)
			{
			iDrive = iDrive->iNextDrive;
			return iDrive;
			}
		iIndex++;
		}

	for (iDrive = NULL; iIndex < KMaxLocalDrives; iIndex++)
		{
		iDrive = TheDrives[iIndex];
		if (iDrive)
			break;
		}

	return iDrive;
	}

/*
Returns the first TLocDrv in the chain of attached drives which matches DPrimaryMediaBase
*/
TLocDrv* TDriveIterator::GetDrive(TInt aDriveNum, DPrimaryMediaBase* aPrimaryMedia)
	{
	TLocDrv* drive = TheDrives[aDriveNum];
	while (drive && drive->iPrimaryMedia != aPrimaryMedia)
		{
		drive = drive->iNextDrive ? drive->iNextDrive : NULL;
		}
	return drive;
	}

/*
Returns the last TLocDrv in the chain of attached drives - 
i.e. the TLocDrv attached to physical media rather than a TLocDrv corresponding to a media extension 
*/
TLocDrv* TDriveIterator::GetPhysicalDrive(TLocDrv* aDrv)
	{
	__ASSERT_DEBUG(aDrv, LOCM_FAULT());
	while (aDrv->iNextDrive)
		aDrv = aDrv->iNextDrive;
	return aDrv;
	}

#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)
DMediaPagingDevice* TDriveIterator::PagingDevice(TInt aDriveNum, DPagingDevice::TType aType)
	{
	TLocDrv* drive = TheDrives[aDriveNum];
	DMediaPagingDevice* pagingDevice = drive ? drive->iPrimaryMedia->iBody->iPagingDevice : NULL;
	while (drive && (pagingDevice == NULL || (pagingDevice->iType & aType) == 0))
		{
		drive = drive->iNextDrive ? drive->iNextDrive : NULL;
		pagingDevice = drive ? drive->iPrimaryMedia->iBody->iPagingDevice : NULL;
		}
	return pagingDevice;
	}
#endif

/********************************************
 * Local drive device base class
 ********************************************/
DECLARE_EXTENSION_LDD()
	{
	return new DLocalDriveFactory;
	}

DLocalDriveFactory::DLocalDriveFactory()
//
// Constructor
//
	{
	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_ENTRY, this );
	iParseMask=KDeviceAllowUnit|KDeviceAllowInfo;
	iUnitsMask=~(0xffffffff<<KMaxLocalDrives);
	iVersion=TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion);
	OstTraceFunctionExit1( DLOCALDRIVEFACTORY_DLOCALDRIVEFACTORY_EXIT, this );
	}

TInt DLocalDriveFactory::Install()
//
// Install the device driver.
//
	{
	return SetName(&KLddName);
	}

void DLocalDriveFactory::GetCaps(TDes8& /*aDes*/) const
//
// Return the Comm capabilities.
//
	{
//	TCapsLocalDriveV01 b;
//	b.version=iVersion;
//	aDes.FillZ(aDes.MaxLength());
//	aDes.Copy((TUint8 *)&b,Min(aDes.MaxLength(),sizeof(b)));
	}

TInt DLocalDriveFactory::Create(DLogicalChannelBase*& aChannel)
//
// Create a channel on the device.
//
	{
	OstTraceFunctionEntry1( DLOCALDRIVEFACTORY_CREATE_ENTRY, this );
	aChannel=new DLocalDrive;
	return aChannel?KErrNone:KErrNoMemory;
	}

/********************************************
 * Local drive interface class
 ********************************************/
DLocalDrive::DLocalDrive() :
	iMediaChangeObserver(MediaChangeCallback, this, TCallBackLink::EDLocalDriveObject)
	{
//	iLink.iNext=NULL;
	}

DLocalDrive::~DLocalDrive()
	{
	OstTraceFunctionEntry1( DLOCALDRIVE_DLOCALDRIVE_ENTRY, this );
	if (iDrive)
		{
		__KTRACE_OPT(KLOCDRV,Kern::Printf(">DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
		iDrive->Disconnect(this);
		__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive::DoClose D:%d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
		}
	DThread* pC=NULL;
	NKern::LockSystem();
	if (iCleanup.iThread)
		{
		pC=iCleanup.iThread;
		iCleanup.Remove();
		iCleanup.iThread=NULL;
		}
	NKern::UnlockSystem();
	if (pC)	// original client may already have terminated
		{
		if (iNotifyChangeRequest)
			Kern::QueueRequestComplete(pC,iNotifyChangeRequest,KErrCancel);
		pC->Close(NULL);	// balances Open() in DoCreate
		}
	if (iNotifyChangeRequest)
		Kern::DestroyClientRequest(iNotifyChangeRequest);
	OstTraceFunctionExit1( DLOCALDRIVE_DLOCALDRIVE_EXIT, this );
	}

TInt DLocalDrive::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer)
	{
    OstTraceFunctionEntry1( DLOCALDRIVE_DOCREATE_ENTRY, this );
    
	if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by ELOCD.LDD (Local Media Driver)")))
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT1, this, KErrPermissionDenied );
		return KErrPermissionDenied;
	    }
	if (!Kern::QueryVersionSupported(TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion),aVer))
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT2, this, KErrNotSupported );
		return KErrNotSupported;
	    }

	NKern::ThreadEnterCS();
	TInt r = Kern::CreateClientDataRequest(iNotifyChangeRequest);
	NKern::ThreadLeaveCS();
	if (r != KErrNone)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT3, this, r );
		return r;
	    }
	
	DThread& t=Kern::CurrentThread();
	NKern::LockSystem();
	t.AddCleanup(&iCleanup);
	NKern::UnlockSystem();
	t.Open();
	iNotifyChangeRequest->SetDestPtr((TBool*) anInfo);

	iDrive=TheDrives[aUnit];
	if (!iDrive)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT4, this, KErrNotSupported );
		return KErrNotSupported;
	    }
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DLocalDrive Create - connect to drive %d, M:%08x",iDrive->iDriveNumber,iDrive->iMedia));
	r=iDrive->Connect(this);
	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive Create D:%d, M:%08x r:%d",iDrive->iDriveNumber,iDrive->iMedia,r));

	if (r!=KErrNone)
		iDrive=NULL;	// didn't connect so don't disconnect
	
	OstTraceFunctionExitExt( DLOCALDRIVE_DOCREATE_EXIT5, this, r );
	return r;
	}

#if defined(_DEBUG)
void DebugDumpDriveCaps(const TLocDrv* aDrive, const TAny* aCaps)
	{
	const TLocalDriveCapsV5& c=*(const TLocalDriveCapsV5*)aCaps;
	Kern::Printf("Drive %d Caps:", aDrive->iDriveNumber);
	Kern::Printf("Size: %lx", c.iSize);
	Kern::Printf("Type: %08x", c.iType);
	Kern::Printf("Bus : %08x", c.iConnectionBusType);
	Kern::Printf("DAtt: %08x", c.iDriveAtt);
	Kern::Printf("MAtt: %08x", c.iMediaAtt);
	Kern::Printf("Base: %08x", c.iBaseAddress);
	Kern::Printf("FSID: %04x", c.iFileSystemId);
	Kern::Printf("PTYP: %04x", c.iPartitionType);
	Kern::Printf("HIDN: %08x", c.iHiddenSectors);
	Kern::Printf("EBSZ: %08x", c.iEraseBlockSize);
    //---------------- V5 ------------------//
    if (c.iSerialNumLength != 0)
        {
        Kern::Printf("SN: length is %d", c.iSerialNumLength);
        TBuf8<2*KMaxSerialNumLength+20> snBuf;
        snBuf.Append(_L8("SN: content is "));
        for (TUint i=0; i<c.iSerialNumLength; i++)
            snBuf.AppendNumFixedWidth(c.iSerialNum[i], EHex, 2);
        Kern::Printf((const char*)snBuf.Ptr());
        }
    else
        Kern::Printf("SN: not supported");
	}
#endif

/*
 * Requests are passed in message as follows:
 * iValue	= request ID
 * iArg[0,1]= Position
 * iArg[2,3]= Length
 * iArg[4]	= Pointer to remote thread (NULL if client)
 * iArg[5]	= Pointer to remote descriptor
 * iArg[6]	= Offset into remote descriptor
 * iArg[7]	= Flags (whole media)
 * iArg[8]	= Pointer to TLocDrv
 */

TInt DLocalDrive::Request(TInt aFunction, TAny* a1, TAny* a2)
	{
	OstTraceFunctionEntry1( DLOCALDRIVE_REQUEST_ENTRY, this );
	__TRACE_TIMING(0);
	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DLocalDrive::DoControl D:%d M:%08x F:%d A1:%08x A2:%08x",
														iDrive->iDriveNumber, iDrive->iMedia, aFunction, a1, a2));
	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST, "iMedia=0x%08x; iDriveNumber=%d; Request Id=%d", (TUint) iDrive->iMedia, (TInt) iDrive->iDriveNumber, (TInt) aFunction );
	
	TInt r=KErrNotSupported;
	TLocDrvRequest& m=TLocDrvRequest::Get();
	m.Flags()=0;
	m.Drive()=iDrive;
	switch (aFunction)
		{
		case RLocalDrive::EControlRead:
			{
			m.Id()=ERead;
			r=m.ProcessMessageData(a1);
			__TRACE_TIMING(1);
			if (r==KErrNone)
				{
				__TRACE_TIMING(2);
				OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ, "ERead iDriveNumber=%d; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) &m);
				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ2, "ERead length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
				r=iDrive->Request(m);
				__TRACE_TIMING(3);
				OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ_RETURN, "ERead Return iDriveNumber=%d; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) &m );
				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READ_RETURN2, "ERead Return length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
				}
			m.CloseRemoteThread();
			break;
			}
		case RLocalDrive::EControlWrite:
			{
			m.Id()=EWrite;
			r=m.ProcessMessageData(a1);
			if (r==KErrNone)
				{
				OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE, "EWrite iDriveNumber=%d; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) &m );
				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE2, "EWrite length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
				r=iDrive->Request(m);
				OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE_RETURN, "EWrite Return iDriveNumber=%d; TLocDrvRequest Object=0x%x", (TInt) iDrive->iDriveNumber, (TUint) &m );
				OstTraceDefExt4( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITE_RETURN2, "EWrite Return length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
				}
			m.CloseRemoteThread();
			break;
			}
		case RLocalDrive::EControlCaps:
			{
			TBuf8<KMaxLocalDriveCapsLength> capsBuf;
			capsBuf.SetMax();
			capsBuf.FillZ();
			m.Id()=ECaps;
			m.RemoteDes()=(TAny*)capsBuf.Ptr();	// overload this
			m.Length()=KMaxLocalDriveCapsLength;	// for pinning
			r=iDrive->Request(m);


#if defined(OST_TRACE_COMPILER_IN_USE) && defined(_DEBUG)
			const TLocalDriveCapsV5& caps=*(const TLocalDriveCapsV5*)capsBuf.Ptr();
#endif
			
			OstTraceExt5( TRACE_INTERNALS, DLOCALDRIVE_REQUEST_CAPS1, "Device caps: iDriveNumber=%d; iSize=0x%x; iType=%d; iDriveAtt=%d; TLocDrvRequest Object=0x%x", (TInt)iDrive->iDriveNumber, (TUint) caps.iSize, (TInt) caps.iType, (TInt) caps.iDriveAtt, (TUint) &m);
			OstTraceExt5( TRACE_INTERNALS, DLOCALDRIVE_REQUEST_CAPS2, "Device caps: iBaseAddress=0x%x; iFileSystemId=%d; iPartitionType=%d; iHiddenSectors=0x%x; iEraseBlockSize=0x%x", (TUint) caps.iBaseAddress, (TInt) caps.iFileSystemId, (TUint) caps.iPartitionType, (TUint) caps.iHiddenSectors, (TUint) caps.iEraseBlockSize);
			
#if defined(_DEBUG)
			__KTRACE_OPT(KLOCDRV,DebugDumpDriveCaps(iDrive,capsBuf.Ptr()));
#endif
			Kern::InfoCopy(*(TDes8*)a1, capsBuf);
			break;
			}
		case RLocalDrive::EControlFormat:
			{
			m.Id()=EFormat;
			r=m.ProcessMessageData(a1);
			if (r==KErrNone)
			    {
			    OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORMAT, "EFormat; TLocDrvRequest Object=0x%x", (TUint) &m);
				r=iDrive->Request(m);
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORMAT_RETURN, "EFormat Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			    }
			break;
			}
		case RLocalDrive::EControlEnlarge:
			if ((TInt)a1<0)
				{
				r=KErrArgument;
				break;
				}
			m.Length()=(TInt)a1;
			m.Id()=EEnlarge;
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_ENLARGE, "EEnlarge; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_ENLARGE_RETURN, "EEnlarge Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
		case RLocalDrive::EControlReduce:
			{
			if ((TInt)a1<0 || (TInt)a2<0)
				{
				r=KErrArgument;
				break;
				}
			m.Pos()=(TInt)a1;
			m.Length()=(TInt)a2;
			m.Id()=EReduce;
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_REDUCE, "EReduce; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_REDUCE_RETURN, "EReduce Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
			}
		case RLocalDrive::EControlForceMediaChange:
			m.Pos()=(TInt)a1;
			m.Id()=EForceMediaChange;
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORCEMEDIACHANGE, "EForceMediaChange; TLocDrvRequest Object=0x%x", (TUint) &m);
			r = iDrive->Request(m);
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_FORCEMEDIACHANGE_RETURN, "EForceMediaChange Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
		case RLocalDrive::EControlMediaDevice:
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLMEDIADEVICE, "EControlMediaDevice; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->iPrimaryMedia->iDevice;
			break;
		case RLocalDrive::EControlIsRemovable:
			{
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLISREMOVABLE, "EControlIsRemovable; TLocDrvRequest Object=0x%x", (TUint) &m);
			TInt sockNum;

			// Pass request on to last chained drive
			TLocDrv* drv = TDriveIterator::GetPhysicalDrive(iDrive);
			r = drv->iPrimaryMedia->IsRemovableDevice(sockNum);

			if (r)
				kumemput32(a1,&sockNum,sizeof(TInt));
			break;	
			}
		case RLocalDrive::EControlControlIO:
			{
			TLocalDriveControlIOData d;
			kumemget32(&d,a1,sizeof(d));

			m.Id() = EControlIO;
			m.iArg[0] = (TAny*) d.iCommand;
			m.iArg[1] = d.iParam1;
			m.iArg[2] = d.iParam2;

			// if d.iHandle is == KLocalMessageHandle (-1),
			//	d.aParam1 and d.aParam2 are TAny* pointers
			//
			// if d.iHandle is == 0, 
			//	d.aParam1 and d.aParam2 are TInts
			//
			// if d.iHandle is > 0, 
			//	d.aParam1 is a data pointer (TUint8*) 
			//	d.aParam2 is an optional extra paramater (TInt)
			//	d.iHandle is a data length (TInt)
			m.iArg[3] = (TAny*) d.iHandle;

			//We're highjacking fields representing
			//length and position in a normal message, so
			//let's not have the dispatcher function attempt
			//to adjust for partition size.
			m.Flags() |= TLocDrvRequest::EAdjusted;
			
	        OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLCONTROLIO, "EControlControlIO; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLCONTROLIO_RETURN, "EControlControlIO Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
			}
		case RLocalDrive::EControlSetMountInfo:
			{
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLSETMOUNTINFO, "EControlSetMountInfo; TLocDrvRequest Object=0x%x", (TUint) &m);
			m.Id()=ERead;
			r=m.ProcessMessageData(a1);

			// Pass request on to last chained drive
			TLocDrv* drv = TDriveIterator::GetPhysicalDrive(iDrive);
			DPrimaryMediaBase* pM = drv->iPrimaryMedia;

			if(!pM || r!=KErrNone)
				break;

			if (pM->iMountInfo.iThread)
				{
				NKern::ThreadEnterCS();
				//Close original thread
				Kern::SafeClose((DObject*&) pM->iMountInfo.iThread,NULL);
				if (m.RemoteDes()!=NULL)
					{
					//Set new mount info and leave setting thread open
#ifdef __DEMAND_PAGING__
					// lock the mount info if this is a data paging media - and keep it locked
					if ((DataPagingDfcQ(pM)) && ((r = LockMountInfo(*pM, m)) != KErrNone))
						break;
#endif
					pM->iMountInfo.iInfo=(TDesC8*)m.RemoteDes();
					pM->iMountInfo.iThread=m.RemoteThread();
					}
				else
					{
					//Clear existing mount info and close setting thread

#ifdef __DEMAND_PAGING__
					// unlock the mount info if this is a data paging media
					UnlockMountInfo(*pM);
#endif

					pM->iMountInfo.iInfo=NULL;
					pM->iMountInfo.iThread=NULL;
					m.CloseRemoteThread();
					}
				NKern::ThreadLeaveCS();
				r=KErrNone;
				}
			else
				{
				//Setting mount info for the first time
				if (m.RemoteDes()==NULL)
					{
					// if no mount info, close setting thread opened in ProcessMessageData()
					m.CloseRemoteThread();
					break;
					}

				NKern::ThreadEnterCS();
#ifdef __DEMAND_PAGING__
				// lock the mount info if this is a data paging media - and keep it locked
				if ((DataPagingDfcQ(pM)) && ((r = LockMountInfo(*pM, m)) != KErrNone))
					break;
#endif

				pM->iMountInfo.iInfo=(TDesC8*)m.RemoteDes();
				pM->iMountInfo.iThread=m.RemoteThread();
				NKern::ThreadLeaveCS();
				r=KErrNone;
				}
			break;
			}
		case RLocalDrive::EControlPasswordLock:
			{
			m.Id()=EPasswordLock;
			m.RemoteDes() = a1;

			TMediaPassword oldPasswd;
			TMediaPassword newPasswd;
			TLocalDrivePasswordData pswData;
			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);

			if (r == KErrNone)
				{
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDLOCK, "EPasswordLock; TLocDrvRequest Object=0x%x", (TUint) &m);
				r = iDrive->Request(m);
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDLOCK_RETURN, "EPasswordLock Return; TLocDrvRequest Object=0x%x", (TUint) &m);
				}
			break;
			}
		case RLocalDrive::EControlPasswordUnlock:
			{
			m.Id()=EPasswordUnlock;
			m.RemoteDes() = a1;

			TMediaPassword oldPasswd;
			TMediaPassword newPasswd;
			TLocalDrivePasswordData pswData;
			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);

			if(r == KErrNone)
				{
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDUNLOCK, "EPasswordUnLock; TLocDrvRequest Object=0x%x", (TUint) &m);
				r=iDrive->Request(m);
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDUNLOCK_RETURN, "EPasswordUnLock Return; TLocDrvRequest Object=0x%x", (TUint) &m);
				}
			if (r == KErrNone)
				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
			break;
			}
		case RLocalDrive::EControlPasswordClear:
			{
			m.Id()=EPasswordClear;
			m.RemoteDes() = a1;

			TMediaPassword oldPasswd;
			TMediaPassword newPasswd;
			TLocalDrivePasswordData pswData;
			r = ReadPasswordData(m, pswData, oldPasswd, newPasswd);

			if (r == KErrNone)
				{
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDCLEAR, "EPasswordClear; TLocDrvRequest Object=0x%x", (TUint) &m);
				r = iDrive->Request(m);
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDCLEAR_RETURN, "EPasswordClear Return; TLocDrvRequest Object=0x%x", (TUint) &m);
				}
			break;
			}
		case RLocalDrive::EControlPasswordErase:
			{
			m.Id()=EPasswordErase;
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDERASE, "EPasswordErase; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDERASE_RETURN, "EPasswordErase Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			if(r == KErrNone)
				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
			break;
			}
		case RLocalDrive::EControlNotifyChange:
			if (iCleanup.iThread != &Kern::CurrentThread())
				Kern::PanicCurrentThread(KLitLocMedia,KErrAccessDenied);
			r=KErrNone;
			if (!iNotifyChangeRequest->StatusPtr())
				r = iNotifyChangeRequest->SetStatus((TRequestStatus*) a1);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLNOTIFYCHANGE, "EControlNotifyChange; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
		case RLocalDrive::EControlNotifyChangeCancel:
			if (iCleanup.iThread != &Kern::CurrentThread())
				Kern::PanicCurrentThread(KLitLocMedia,KErrAccessDenied);
			Kern::QueueRequestComplete(iCleanup.iThread,iNotifyChangeRequest,KErrCancel);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLNOTIFYCHANGECANCEL, "EControlNotifyChangeCancel; TLocDrvRequest Object=0x%x", (TUint) &m);
			break;
		case RLocalDrive::EControlReadPasswordStore:
			{
			TUint8  passData[TPasswordStore::EMaxPasswordLength];
			m.RemoteDes() = (TAny*) passData;
			m.Length() = sizeof(passData);
			m.Id()=EReadPasswordStore;
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READPASSWORDSTORE, "EReadPasswordStore; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_READPASSWORDSTORE_RETURN, "EReadPasswordStore Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			if (r==KErrNone)
				{
				TPtr8 pData(passData, (TInt) m.Length(), TPasswordStore::EMaxPasswordLength);
				m.RemoteDes()=(TDes8*)a1;
				r = m.WriteRemote(&pData,0);
				}
			break;
			}
		case RLocalDrive::EControlWritePasswordStore:
			{
			TUint8  passData[TPasswordStore::EMaxPasswordLength];
			TPtr8 pData(passData, TPasswordStore::EMaxPasswordLength);

			DThread* pT=m.RemoteThread();
			if (!pT)
				pT=m.Client();

			m.RemoteDes() = (TDes8*)a1;
			r = Kern::ThreadGetDesLength(pT, m.RemoteDes());
			if ( r > pData.MaxLength() )
				r = KErrOverflow;
			if ( r < KErrNone)
				break;

			r = m.ReadRemote(&pData,0);
			if (r != KErrNone)
				break;


			m.RemoteDes() = (TAny*) pData.Ptr();
			m.Length() = pData.Length();
			m.Id()=EWritePasswordStore;
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITEPASSWORDSTORE, "EWritePasswordStore; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_WRITEPASSWORDSTORE_RETURN, "EReadPasswordStore Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			if(r == KErrNone)
				iDrive->iPrimaryMedia->iTotalPartitionsOpened = 0;
			break;
			}
		case RLocalDrive::EControlPasswordStoreLengthInBytes:
			{
			m.Id()=EPasswordStoreLengthInBytes;
			TInt length;
			m.RemoteDes() = (TAny*) &length;
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDSTORELENGTH, "EPasswordStoreLengthInBytes; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_PASSWORDSTORELENGTH_RETURN, "EPasswordStoreLengthInBytes Return; TLocDrvRequest Object=0x%x", (TUint) &m);

			if (r == KErrNone)
				{
				m.RemoteDes()=a1;
				r = m.WriteRemoteRaw(&length,sizeof(TInt));
				}
			
			break;
			}
		case RLocalDrive::EControlGetLastErrorInfo:
			{
			m.Id()=EGetLastErrorInfo;
			m.iArg[0]=this;
			TErrorInfoBuf errorInfoBuf;
			errorInfoBuf.SetMax();
			errorInfoBuf.FillZ();
			m.RemoteDes()=(TAny*) errorInfoBuf.Ptr();	// overload this
			m.Length() = errorInfoBuf.MaxLength();
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_GETLASTERRORINFO, "EGetLastErrorInfo; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_CONTROLGETLASTERRORINFO_RETURN, "EControlGetLastErrorInfo Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			Kern::InfoCopy(*(TDes8*)a1, errorInfoBuf);
			break;
			}
		case RLocalDrive::EControlDeleteNotify:
			{
			m.Id()=EDeleteNotify;
			r=m.ProcessMessageData(a1);
			if (r==KErrNone)
			    {
			    OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_DELETENOTIFY, "EDeleteNotify; TLocDrvRequest Object=0x%x", (TUint) &m);
				r=iDrive->Request(m);
				OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_DELETENOTIFY_RETURN, "EDeleteNotify Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			    }
			break;
			}

		case RLocalDrive::EControlQueryDevice:
			{
			TBuf8<KMaxQueryDeviceLength> queryBuf;
			queryBuf.SetMax();
			queryBuf.FillZ();

			DThread* pT = m.Client();
			r = Kern::ThreadDesRead(pT, (TDes8*)a2, queryBuf, 0 ,KChunkShiftBy0);

			queryBuf.SetMax();
			m.Id() = EQueryDevice;
			m.iArg[0] = a1;							// RLocalDrive::TQueryDevice
			m.RemoteDes() = (TAny*)queryBuf.Ptr();	// overload this
			m.Length() = KMaxQueryDeviceLength;
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_QUERYDEVICE, "EQueryDevice; TLocDrvRequest Object=0x%x", (TUint) &m);
			r=iDrive->Request(m);
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DLOCALDRIVE_REQUEST_QUERYDEVICE_RETURN, "EQueryDevice Return; TLocDrvRequest Object=0x%x", (TUint) &m);
			Kern::InfoCopy(*(TDes8*)a2, queryBuf);
			break;
			}

		}
	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DLocalDrive::DoControl D:%d M:%08x ret %d",iDrive->iDriveNumber, iDrive->iMedia, r));
	__TRACE_TIMING(4);
	OstTraceFunctionExitExt( DLOCALDRIVE_REQUEST_EXIT, this, r );
	return r;
	}

TInt DLocalDrive::ReadPasswordData(TLocDrvRequest& aReq, TLocalDrivePasswordData& aPswData, TMediaPassword& aOldPasswd, TMediaPassword& aNewPasswd)
	{
	TLocalDrivePasswordData clientData;
	TInt r = aReq.ReadRemoteRaw(&clientData, sizeof(TLocalDrivePasswordData));

	DThread* pT = aReq.RemoteThread();
	if (!pT)
		pT = aReq.Client();

	if (r == KErrNone)
		r = Kern::ThreadDesRead(pT, clientData.iOldPasswd, aOldPasswd, 0 ,KChunkShiftBy0);
	if (r == KErrNone)
		r = Kern::ThreadDesRead(pT, clientData.iNewPasswd, aNewPasswd, 0 ,KChunkShiftBy0);
	
	aPswData.iStorePasswd = clientData.iStorePasswd;
	aPswData.iOldPasswd = &aOldPasswd;
	aPswData.iNewPasswd = &aNewPasswd;


	aReq.RemoteDes() = (TAny*) &aPswData;
	aReq.Flags()|= TLocDrvRequest::EKernelBuffer;

	return r;
	}


#ifdef __DEMAND_PAGING__
TInt DLocalDrive::LockMountInfo(DPrimaryMediaBase& aPrimaryMedia, TLocDrvRequest& aReq)
	{
	OstTraceExt2(TRACE_FLOW, DLOCALDRIVE_LOCKMOUNTINFO_ENTRY, "> aPrimaryMedia=%x;aReq=%x", (TUint) &aPrimaryMedia, (TUint) &aReq );
	DMediaPagingDevice* pagingDevice = aPrimaryMedia.iBody->iPagingDevice;
	if (pagingDevice == NULL)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT1, this, KErrNone );
		return KErrNone;
	    }

	__ASSERT_DEBUG(pagingDevice->iMountInfoDataLock == NULL, LOCM_FAULT());
	__ASSERT_DEBUG(pagingDevice->iMountInfoDescHdrLock == NULL, LOCM_FAULT());
	__ASSERT_DEBUG(pagingDevice->iMountInfoDescLenLock == NULL, LOCM_FAULT());

	DThread* pT = aReq.RemoteThread();
	if (!pT)
		pT = &Kern::CurrentThread();	// e.g. when using TBusLocalDrive directly

	TInt length = 0;
	TInt maxLength = 0;
	TUint8* desAddress = NULL;
	TInt r = Kern::ThreadGetDesInfo(pT,aReq.RemoteDes(),length,maxLength,desAddress,EFalse);	// get descriptor length, maxlength and desAddress
	if (r != KErrNone)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT2, this, r );
		return r;
	    }
	if (length == 0)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT3, this, KErrNone );
		return KErrNone;
	    }


	static const TUint8 LengthLookup[16]={4,8,12,8,12,0,0,0,0,0,0,0,0,0,0,0};
	TUint32 desHdr;
	r = Kern::ThreadRawRead(pT, aReq.RemoteDes(), &desHdr, sizeof(desHdr));
	if(r!=KErrNone)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT4, this, r );
		return r;
	    }
	TInt desType = desHdr >>KShiftDesType8;
	TInt desHdrLen = LengthLookup[desType];
	if(!desHdrLen)
	    {
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT5, this, KErrBadDescriptor );
		return KErrBadDescriptor;
	    }


	pagingDevice->iMountInfoDataLock = ThePinObjectAllocator->AcquirePinObject();
	pagingDevice->iMountInfoDescHdrLock = ThePinObjectAllocator->AcquirePinObject();
	pagingDevice->iMountInfoDescLenLock = ThePinObjectAllocator->AcquirePinObject();

	if (pagingDevice->iMountInfoDataLock == NULL || 
		pagingDevice->iMountInfoDescHdrLock == NULL || 
		pagingDevice->iMountInfoDescLenLock == NULL)
		{
		UnlockMountInfo(aPrimaryMedia);	// tidy up
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT6, this, KErrNoMemory );
		return KErrNoMemory;
		}


	// First pin the descriptor header 
	DPinObjectAllocator::SVirtualPinContainer* lock;
	lock = (DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescHdrLock;
	r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) (TUint8*) aReq.RemoteDes(), desHdrLen, pT);
	if (r != KErrNone)
		{
		UnlockMountInfo(aPrimaryMedia);	// tidy up
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT7, this, KErrNoMemory );
		return KErrNoMemory;
		}

	
	
	// For EBufCPtr-type descriptors, need to pin the extra length before the buffer (!)
	lock = (DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescLenLock;
	if (desType == EBufCPtr)
		{
		TLinAddr extraLenAddr = TLinAddr(desAddress) - aReq.RemoteDesOffset() - sizeof(TUint32);
		r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) (TUint8*) extraLenAddr, sizeof(TUint32), pT);
		if (r != KErrNone)
			{
			UnlockMountInfo(aPrimaryMedia);	// tidy up
			OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT8, this, KErrNoMemory );
			return KErrNoMemory;
			}
		}


	// Now pin the descriptor contents
	lock = (DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDataLock;
	r = Kern::PinVirtualMemory(lock->iObject, (TLinAddr) desAddress, length, pT);
	if (r != KErrNone)
		{
		UnlockMountInfo(aPrimaryMedia);	// tidy up
		OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT9, this, KErrNoMemory );
		return KErrNoMemory;
		}

	OstTraceFunctionExitExt( DLOCALDRIVE_LOCKMOUNTINFO_EXIT10, this, KErrNone );
	return KErrNone;
	}


void DLocalDrive::UnlockMountInfo(DPrimaryMediaBase& aPrimaryMedia)
	{
	OstTrace1(TRACE_FLOW, DLOCALDRIVE_UNLOCKMOUNTINFO_ENTRY, "> DLocalDrive::UnlockMountInfo;aPrimaryMedia=%x", (TUint) &aPrimaryMedia);
	
	DMediaPagingDevice* pagingDevice = aPrimaryMedia.iBody->iPagingDevice; 
	if (pagingDevice == NULL)
	    {
		OstTraceFunctionExit1( DLOCALDRIVE_UNLOCKMOUNTINFO_EXIT1, this );
		return;
	    }


	if (pagingDevice->iMountInfoDataLock)
		{
		Kern::UnpinVirtualMemory(((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDataLock)->iObject);
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDataLock);
		pagingDevice->iMountInfoDataLock = NULL;
		}
	
	if (pagingDevice->iMountInfoDescHdrLock)
		{
		Kern::UnpinVirtualMemory(((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescHdrLock)->iObject);
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescHdrLock);
		pagingDevice->iMountInfoDescHdrLock = NULL;
		}
	
	if (pagingDevice->iMountInfoDescLenLock)
		{
		Kern::UnpinVirtualMemory(((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescLenLock)->iObject);
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) pagingDevice->iMountInfoDescLenLock);
		pagingDevice->iMountInfoDescLenLock = NULL;
		}
	
	OstTraceFunctionExit1( DLOCALDRIVE_UNLOCKMOUNTINFO_EXIT2, this );
	}
#endif	// __DEMAND_PAGING__

void DLocalDrive::NotifyChange()
	{
    OstTrace0( TRACE_FLOW, DLOCALDRIVE_NOTIFYCHANGE_ENTRY, "> DLocalDrive::NotifyChange");


	// Complete any notification request on media change
	DThread* pC=NULL;
	NKern::LockSystem();
	if (iCleanup.iThread)
		{
		pC=iCleanup.iThread;
		pC->Open();
		}
	NKern::UnlockSystem();
	if (pC)
		{
		TBool b = ETrue;
		// if change not yet queued, queue it now
		if (iNotifyChangeRequest->IsReady())
			{
			*((TBool*) iNotifyChangeRequest->Buffer()) = b;
			Kern::QueueRequestComplete(pC,iNotifyChangeRequest,KErrNone);
			}
		// If change has not even been requested by the client, maintain the pre-wdp behaviour 
		// and write data immediately back to client (possibly taking a page fault)
		// N.B. Must NOT do this on data paging media
#ifdef __DEMAND_PAGING__
		else if (!DataPagingDfcQ(iDrive->iPrimaryMedia))
#else
		else
#endif
			{
			Kern::ThreadRawWrite(pC, iNotifyChangeRequest->DestPtr(), &b, sizeof(b), NULL);
			}
		pC->AsyncClose();
		}
	OstTraceFunctionExit1( DLOCALDRIVE_NOTIFYCHANGE_EXIT, this );
	}

// This function is called by the primary media when a media change occurs
TInt DLocalDrive::MediaChangeCallback(TAny* aLocalDrive, TInt /* aNotifyType*/)
	{
	((DLocalDrive*) aLocalDrive)->NotifyChange();
	return KErrNone;
	}

TLocalDriveCleanup::TLocalDriveCleanup()
	{
	}

// This will be called when the original client thread exits
// It is called in the context of the exiting thread with the system locked.
void TLocalDriveCleanup::Cleanup()
	{
	DLocalDrive& d=LocalDrive();
	d.iNotifyChangeRequest=NULL;
	DThread* pC=iThread;
	Remove();
	iThread=NULL;
	NKern::UnlockSystem();
	pC->Close(NULL);	// balances Open() in DoCreate
	NKern::LockSystem();
	}


EXPORT_C TInt DLocalDrive::Caps(TInt aDriveNumber, TDes8& aCaps)
	{
	if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by ELOCD.LDD (Local Media Driver)")))
	    {
		return KErrPermissionDenied;
	    }
	

	if (aDriveNumber >= KMaxLocalDrives)
		return KErrArgument;

	TLocDrv* drive = TheDrives[aDriveNumber];
	if (!drive)
		return KErrNotSupported;

	TLocDrvRequest request;
	memclr(&request, sizeof(request));

	request.Drive() = drive;
	request.Id() = DLocalDrive::ECaps;
	request.Length() = aCaps.Length();
	request.RemoteDes() = (TAny*) aCaps.Ptr();

	return request.SendReceive(&drive->iPrimaryMedia->iMsgQ);
	}

/********************************************
 * Local drive request class
 ********************************************/
 
/**
Reads data from the descriptor specified in the request, from the requesting
thread's process.

This is used by the media driver to read data from a descriptor in the
requesting thread.  The remote data is copied into the specified descriptor,
starting at the specified offset within that descriptor's data area.

@param aDes     The target descriptor into which data from the remote thread
                is to be put.
@param anOffset The offset within the target descriptor data area, where data
                from the remote thread is to be put. Note that this parameter
                may be useful when write operations to the media must be broken
                up into smaller chunks than the length requested.

@return KErrNone,if successful, otherwise one of the other
        system-wide error codes.

@see Kern::ThreadDesRead()
*/
EXPORT_C TInt TLocDrvRequest::ReadRemote(TDes8* aDes, TInt anOffset)
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_READREMOTE_ENTRY, this );
	TInt r;

	if (Flags() & TLocDrvRequest::EKernelBuffer)
		{
		(void)memcpy((TAny*) aDes->Ptr(), (TAny*)((TUint32)RemoteDes()+anOffset), aDes->MaxLength());
		aDes->SetLength(aDes->MaxLength());
		return KErrNone;
		}

	DThread* pT=RemoteThread();
	if (!pT)
		pT=Client();

#ifdef __DEMAND_PAGING__	// only if driver has its own thread, we don't support paging in MD which run in the context of their clients
	if (Flags() & ETClientBuffer)
	    {
        r = Kern::ThreadBufRead(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
		OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTE_EXIT1, this, r );
		return r; 
	    }
	
	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
#endif
	r = Kern::ThreadDesRead(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0);
	OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTE_EXIT2, this, r );
	return r;
	}




/**
Reads data from an arbitrary descriptor in the requesting thread's process.

This is used by the media driver to read data from a descriptor in the
requesting thread.  

NB This is NOT supported on datapaging media as there is no guarantee 
that the remote descriptor won't be paged out. If this function is called and
data-paging is enabled the kernel will fault in debug mode and return 
KErrNotSupported in release mode.

@param aSrc     A pointer to the source descriptor in the requesting thread's
                address space.
@param aDes     The target descriptor into which data from the remote thread
                is to be put.

@return KErrNone,if successful, 
		KErrNotSupported if data-paging is enabled
		otherwise one of the other  system-wide error codes.

@see Kern::ThreadDesRead()
*/
EXPORT_C TInt TLocDrvRequest::ReadRemote(const TAny* aSrc, TDes8* aDes)
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_READ_REMOTE_ENTRY, this );
	if (Flags() & TLocDrvRequest::EKernelBuffer)
		{
		aDes->Copy(* (TDesC8*) aSrc);
		return KErrNone;
		}

	TInt r;
	DThread* pT=RemoteThread();
	if (!pT)
		pT=Client();

#ifdef __DEMAND_PAGING__
	__ASSERT_DEBUG(!DataPagingDfcQ(Drive()->iPrimaryMedia), LOCM_FAULT());

	if (DataPagingDfcQ(Drive()->iPrimaryMedia))
		{
		OstTraceFunctionExitExt( TLOCDRVREQUEST_READ_REMOTE_EXIT1, this, KErrNotSupported );
		return KErrNotSupported;
	    }
#endif
	
	r = Kern::ThreadDesRead(pT,aSrc,*aDes,0,KChunkShiftBy0);
	OstTraceFunctionExitExt( TLOCDRVREQUEST_READ_REMOTE_EXIT2, this, r );
	return r;
	}




/**
Reads raw data from the requesting thread's process.

This is used by the media driver to read raw data from a location in requesting
thread's address space.  The remote data is copied into the specified
buffer.

@param aDest    A pointer to the buffer where the data is to be written.
@param aSize    The number of bytes to read.

@return KErrNone,if successful, otherwise one of the other
        system-wide error codes.

@see Kern::ThreadRawRead()
*/
EXPORT_C TInt TLocDrvRequest::ReadRemoteRaw(TAny* aDest, TInt aSize)
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_READREMOTERAW_ENTRY, this );
	if (Flags() & TLocDrvRequest::EKernelBuffer)
		{
		(void)memcpy(aDest, (TAny*) RemoteDes(), aSize);
		return KErrNone;
		}

	TInt r;
	DThread* pT=RemoteThread();
	if (!pT)
		pT=Client();

#ifdef __DEMAND_PAGING__
	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
#endif
	
	r = Kern::ThreadRawRead(pT,RemoteDes(),aDest,aSize);
	OstTraceFunctionExitExt( TLOCDRVREQUEST_READREMOTERAW_EXIT, this, r );
	return r;
	}


/**
Writes data to a descriptor in the requesting thread's process.

This is used by the media driver to write data to a descriptor in the requesting
thread.  Data is copied from the specified descriptor, starting at the specified
offset within that descriptor's data area.

@param aDes     The source descriptor from which data is to be written to
                the remote thread.
                
@param anOffset The offset within the source descriptor data area, from where data
                is to be written to the remote thread. Note that this parameter
                may be useful when read operations from the media must be broken
                up into smaller chunks than the length requested.

@return KErrNone,if successful, otherwise one of the other
        system-wide error codes.

@see Kern::ThreadDesWrite()
*/
EXPORT_C TInt TLocDrvRequest::WriteRemote(const TDesC8* aDes, TInt anOffset)
	{
    OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITEREMOTE_ENTRY, this );
    TInt r;

	if (Flags() & TLocDrvRequest::EKernelBuffer)
		{
		(void)memcpy((TAny*)((TUint32)RemoteDes()+anOffset), (TAny*) aDes->Ptr(), aDes->Length());
		OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTE_EXIT1, this, KErrNone );
		return KErrNone;
		}

	DThread* pC=Client();
	DThread* pT=RemoteThread();
	if (!pT)
		pT=pC;

#ifdef __DEMAND_PAGING__
	if (Flags() & ETClientBuffer)
	    {
        r = Kern::ThreadBufWrite(pT, (TClientBuffer*) RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
		OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTE_EXIT2, this, r );
		return r;
	    }
#endif
	r = Kern::ThreadDesWrite(pT,RemoteDes(),*aDes,anOffset+RemoteDesOffset(),KChunkShiftBy0,pC);
	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTE_EXIT3, this, r );
	return r;
	}


/**
Writes raw data to the requesting thread's process.

This is used by the media driver to write raw data to a location in the
requesting thread's address space.

@param aSrc     The source addres from which data is to be written to
                the remote thread.
                
@param aSize    The number of bytes to write.

@return KErrNone,if successful, otherwise one of the other
        system-wide error codes.

@see Kern::ThreadRawWrite()
*/
EXPORT_C TInt TLocDrvRequest::WriteRemoteRaw(const TAny* aSrc, TInt aSize)
	{
    OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITEREMOTERAW_ENTRY, this );
    TInt r;
	DThread* pC=Client();
	DThread* pT=RemoteThread();
	if (!pT)
		pT=pC;

#ifdef __DEMAND_PAGING__
	__ASSERT_ALWAYS((Flags() & ETClientBuffer) == 0, LOCM_FAULT());
#endif
	r = Kern::ThreadRawWrite(pT,RemoteDes(),aSrc,aSize,pC);
	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITEREMOTERAW_EXIT, this, r );
	return r;
	}


TInt TLocDrvRequest::ProcessMessageData(TAny* aPtr)
//
// Get read/write parameters from client and open remote thread
//
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_PROCESSMESSAGEDATA_ENTRY, this );
	RemoteThread()=NULL;
	DThread& t=Kern::CurrentThread();
	TLocalDriveMessageData d;
	kumemget32(&d,aPtr,sizeof(d));
	OstTrace1( TRACE_INTERNALS, TLOCDRVREQUEST_PROCESSMESSAGEDATA, "Message handle=%d", d.iHandle );
	if (d.iHandle!=KLocalMessageHandle && Id()!=DLocalDrive::EFormat)
		{
		NKern::LockSystem();
		DThread* pT = RMessageK::MessageK(d.iHandle)->iClient;
		if (!pT || pT->Open()!=KErrNone)
			{
			NKern::UnlockSystem();
			OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT1, this, KErrBadHandle );
			return KErrBadHandle;
			}
		t.iExtTempObj=pT;
		RemoteThread()=pT;
		NKern::UnlockSystem();
		}
	Pos()=d.iPos;
	Length()=d.iLength;
	RemoteDes()=(TAny*)d.iPtr;
	RemoteDesOffset()=d.iOffset;
	DriverFlags()=d.iFlags;
	
	// EPhysAddrOnly should not be set for client requests
	Flags() &= ~TLocDrvRequest::EPhysAddrOnly;
	
	if (Pos()<0 || Length()<0)
	    {
		OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT2, this, KErrArgument );
		return KErrArgument;
	    }
	OstTraceFunctionExitExt( TLOCDRVREQUEST_PROCESSMESSAGEDATA_EXIT3, this, KErrNone );
	return KErrNone;
	}

void TLocDrvRequest::CloseRemoteThread()
	{
    OstTraceFunctionEntry1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_ENTRY, this );
    
	if (!RemoteThread())
	    {
		OstTraceFunctionExit1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_EXIT1, this );
		return;
	    }
	NKern::ThreadEnterCS();
	DThread& t=Kern::CurrentThread();
	RemoteThread()=NULL;
	Kern::SafeClose((DObject*&)t.iExtTempObj,NULL);
	NKern::ThreadLeaveCS();
	OstTraceFunctionExit1( TLOCDRVREQUEST_CLOSEREMOTETHREAD_EXIT2, this );
	}

EXPORT_C TInt TLocDrvRequest::CheckAndAdjustForPartition()
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION_ENTRY, this );
	TLocDrv& d=*Drive();
	__KTRACE_OPT(KLOCDRV,Kern::Printf("CheckAndAdjustForPartition drive %d partition len %lx",d.iDriveNumber,d.iPartitionLen));
	OstTraceExt3( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION1, "iDriveNumber=%d; partition length=%x:%x", d.iDriveNumber, (TInt) I64HIGH (d.iPartitionLen), (TInt) I64LOW (d.iPartitionLen));
	Flags() |= EAdjusted;
	TInt r;
	switch (Id())
		{
		case DLocalDrive::ECaps:
		case DLocalDrive::EForceMediaChange:
		case DLocalDrive::EPasswordLock:
		case DLocalDrive::EPasswordUnlock:
		case DLocalDrive::EPasswordClear:
		case DLocalDrive::EPasswordErase:
		case DLocalDrive::EReadPasswordStore:
 		case DLocalDrive::EWritePasswordStore:
 		case DLocalDrive::EPasswordStoreLengthInBytes:
		case DLocalDrive::EQueryDevice:
		    {
			r = KErrNone;
			break;
		    }
		case DLocalDrive::EEnlarge:
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Enlarge request %lx",Length()));
			OstTraceExt2( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION2, "Enlarge request=%x:%x", (TInt) I64HIGH(Length()), (TInt) I64LOW(Length()) );
			if (Length()>KMaxTInt)
				r = KErrArgument;
			else
			    r = KErrNone;
			break;
		case DLocalDrive::EReduce:
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Reduce request %lx@%lx",Length(),Pos()));
			OstTraceExt4( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION3, "Reduce request length=%x:%x; position=%x:%x", (TUint) I64HIGH(Length()), (TUint) I64LOW(Length()), (TUint) I64HIGH (Pos()), (TUint) I64LOW (Pos()) );
			if (Pos()+Length()>d.iPartitionLen)
				r = KErrArgument;
			else
                r = KErrNone;
			break;
		case DLocalDrive::EFormat:
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Format request %lx@%lx",Length(),Pos()));
			OstTraceExt4( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION4, "Format request length=%x:%x; position=%x:%x", (TUint) I64HIGH(Length()),(TUint) I64LOW(Length()), (TUint) I64HIGH (Pos()), (TUint) I64LOW (Pos()) );
			if (!(DriverFlags() & RLocalDrive::ELocDrvWholeMedia))
				{
				if (Pos()>d.iPartitionLen)
					{
					Length()=0;
					r = KErrEof;
					break;
					}
				Int64 left=d.iPartitionLen-Pos();
				if (left<Length())
					Length()=left;
				Pos()+=d.iPartitionBaseAddr;
				if (Length()==0)
				    {
					r = KErrEof;
					break;
				    }
				}
			r = KErrNone;
			break;

#ifdef __DEMAND_PAGING__
		case DMediaPagingDevice::ERomPageInRequest:
//          if the ROM was reported to LOCM then it will also need to be adjusted.... 
//		    Otherwise the media driver adjust it internally
		case DMediaPagingDevice::ECodePageInRequest:
			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Adjusted Paging read request %lx@%lx",Length(),Pos()));
			OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, TLOCDRVREQUESTCHECKANDADJUSTFORPARTITION5, "Adjusted Paging read request length=%x:%x; position=%x%:%x", (TUint) I64HIGH(Length()), (TUint) I64LOW(Length()),  (TUint) I64HIGH (Pos()), (TUint) I64LOW (Pos()));
			if (Pos()+Length()>d.iPartitionLen)
			    {
				r = KErrArgument;
				break;
			    }
			Pos()+=d.iPartitionBaseAddr;
			r = KErrNone;
			break;
#endif
		
		default:	// read or write or fragment
			__KTRACE_OPT(KLOCDRV,Kern::Printf("R/W request %lx@%lx",Length(),Pos()));
			OstTraceExt4( TRACE_INTERNALS, TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION6, "Read/Write request length=%x:%x; position=%x:%x", (TUint)I64HIGH (Length()), (TUint)I64LOW (Length()), (TUint) I64HIGH (Pos()), (TUint) I64LOW (Pos()));
			if (DriverFlags() & RLocalDrive::ELocDrvWholeMedia)
				{
				if (d.iMedia && d.iMedia->iDriver && Pos()+Length() > d.iMedia->iPartitionInfo.iMediaSizeInBytes)
				    {
					r = KErrArgument;
					break;
				    }
				}
			else
				{
				if (Pos()+Length() > d.iPartitionLen)
				    {
					r = KErrArgument;
					break;
				    }
				Pos()+=d.iPartitionBaseAddr;
				}
		r = KErrNone;
		}
	OstTraceFunctionExitExt( TLOCDRVREQUEST_CHECKANDADJUSTFORPARTITION_EXIT, this, r );
	return r;
	}

/********************************************
 * Local drive class
 ********************************************/
TLocDrv::TLocDrv(TInt aDriveNumber)
	{
	OstTraceFunctionEntryExt( TLOCDRV_TLOCDRV_ENTRY, this );
	memclr(this, sizeof(TLocDrv));
	iDriveNumber=aDriveNumber;
	iPartitionNumber=-1;
	iMediaChangeObserver.iFunction = MediaChangeCallback;
	iMediaChangeObserver.iPtr= this;
	iMediaChangeObserver.iObjectType = TCallBackLink::ETLocDrvObject;
	OstTraceFunctionExit1( TLOCDRV_TLOCDRV_EXIT, this );
	}

TInt TLocDrv::MediaChangeCallback(TAny* aLocDrv, TInt aNotifyType)
	{
	__ASSERT_DEBUG(aNotifyType == DPrimaryMediaBase::EMediaChange || aNotifyType == DPrimaryMediaBase::EMediaPresent, LOCM_FAULT());
	if (aNotifyType == DPrimaryMediaBase::EMediaPresent)
		return ((TLocDrv*) aLocDrv)->iPrimaryMedia->iBody->iMediaPresentDfc.Enque();
	else
		return ((TLocDrv*) aLocDrv)->iPrimaryMedia->iBody->iMediaChangeDfc.Enque();
	}


/**
Initialises the DMedia entity with the media device number and ID.
 
@param	aDevice		The unique ID for this device. This can take one of the
					enumerated values defined in TMediaDevice enum.

@param	aMediaId	The unique ID to associate with this media entity.

@return KErrNone,if successful, otherwise one of the other
        system-wide error codes.

@see	TMediaDevice
*/
EXPORT_C TInt DMedia::Create(TMediaDevice aDevice, TInt aMediaId, TInt)
	{
	OstTraceFunctionEntry1( DMEDIA_CREATE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMedia::Create media %d device %d",aMediaId,aDevice));
	OstTraceExt2(TRACE_INTERNALS, DMEDIA_CREATE, "media=%d; device=%d", aMediaId, (TUint) aDevice);
	iMediaId=aMediaId;
	iDevice=aDevice;
	OstTraceFunctionExitExt( DMEDIA_CREATE_EXIT, this, KErrNone );
	return KErrNone;
	}

/********************************************
 * Primary Media Class
 ********************************************/
void asyncDfc(TAny* aPtr)
	{
	OstTraceFunctionEntry0( _ASYNCDFC_ENTRY );
	DPrimaryMediaBase* pM=(DPrimaryMediaBase*)aPtr;
	if (pM->iState==DMedia::EOpening)
		pM->DoOpenMediaDriverComplete(pM->iAsyncErrorCode);
	else if (pM->iState==DMedia::EReadPartitionInfo)
		pM->DoPartitionInfoComplete(pM->iAsyncErrorCode);
	OstTraceFunctionExit0( _ASYNCDFC_EXIT );
	}

void handleMsg(TAny* aPtr)
	{
	OstTraceFunctionEntry0( _HANDLEMSG_ENTRY );
	DPrimaryMediaBase* primaryMedia=(DPrimaryMediaBase*)aPtr;

	for(TLocDrvRequest* m = (TLocDrvRequest*) primaryMedia->iMsgQ.iMessage; 
		m != NULL; 
		m = (TLocDrvRequest*) primaryMedia->iMsgQ.Poll())
		{
#if defined(_DEBUG)	
		if (!primaryMedia->iMsgQ.iQ.IsEmpty())	
			__KTRACE_OPT(KLOCDRV, Kern::Printf("TRACE: handleMsg, queue not empty %08X", m));	
#endif
		primaryMedia->HandleMsg(*m);
		
#ifdef __DEMAND_PAGING__
		// don't empty the queue if this media is paging as there 
		// may be a (higher-priority) paging DFC waiting to run...
		if (primaryMedia->iPagingMedia)
			break;
#endif
		}


	primaryMedia->iMsgQ.Receive();	// allow reception of more messages
	OstTraceFunctionExit0( _HANDLEMSG_EXIT );
	}


void mediaChangeDfc(TAny* aPtr)
	{
	DPrimaryMediaBase* pM = (DPrimaryMediaBase*)aPtr;
	pM->NotifyMediaChange();
	}

void mediaPresentDfc(TAny* aPtr)
	{
	DPrimaryMediaBase* pM = (DPrimaryMediaBase*)aPtr;
	pM->NotifyMediaPresent();
	}

DPrimaryMediaBase::DBody::DBody(DPrimaryMediaBase& aPrimaryMediaBase) :
	iPrimaryMediaBase(aPrimaryMediaBase),
	iMediaChangeDfc(mediaChangeDfc, &aPrimaryMediaBase, KMaxDfcPriority),
	iMediaPresentDfc(mediaPresentDfc, &aPrimaryMediaBase, KMaxDfcPriority)
	{
	}

EXPORT_C DPrimaryMediaBase::DPrimaryMediaBase()
	:	iMsgQ(handleMsg, this, NULL, 1),
		iDeferred(NULL, NULL, NULL, 0),			// callback never used
		iWaitMedChg(NULL, NULL, NULL, 0),		// callback never used
		iAsyncDfc(asyncDfc, this, 1)
/**
Constructor of DPrimaryMediaBase class.
Initialises the media state as closed.
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DPRIMARYMEDIABASE_ENTRY, this );
	iState = EClosed;
	}



EXPORT_C TInt DPrimaryMediaBase::Create(TMediaDevice aDevice, TInt aMediaId, TInt aLastMediaId)
/**
Called from LocDrv::RegisterMediaDevice() function.
Calls DMedia::Create()

@param aDevice Local media ID 
@param aMediaId Media Id (unique for a media subsystem)
@param aLastMediaId This indicates number of used media ids+ number of DMedia objects to be associated with the media driver.

@return KErrNone
@see TMediaDevice 

*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_CREATE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase::Create media %d-%d device %d",aMediaId,aLastMediaId,aDevice));
	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_CREATE, "aMediaId=%d; aLastMediaId=%d; aDevice=%d ", aMediaId, aLastMediaId, (TUint) aDevice );
	TInt r=DMedia::Create(aDevice,aMediaId,0);
	
	if (r != KErrNone)
	    {
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT1, this, r );
		return r;
		}
	iBody = new DBody(*this);
	if (iBody == NULL)
	    {
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT2, this, KErrNoMemory );
		return KErrNoMemory;
		}
	if (iDfcQ)
		{
		iBody->iMediaChangeDfc.SetDfcQ(iDfcQ);
		iBody->iMediaPresentDfc.SetDfcQ(iDfcQ);
		}

#ifdef __DEMAND_PAGING__
	TInt pageSize = Kern::RoundToPageSize(1);
	iBody->iPageSizeMsk = pageSize-1;
	iBody->iPageSizeLog2 = __e32_find_ms1_32(pageSize);
#endif

	iLastMediaId=aLastMediaId;
	if (r==KErrNone && iDfcQ)
		{
		iMsgQ.SetDfcQ(iDfcQ);
		iDeferred.SetDfcQ(iDfcQ);
		iWaitMedChg.SetDfcQ(iDfcQ);
		iAsyncDfc.SetDfcQ(iDfcQ);
		}
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CREATE_EXIT3, this, KErrNone );
	return KErrNone;
	}


EXPORT_C TInt DPrimaryMediaBase::Connect(DLocalDrive* aLocalDrive)
/**
Connects to a local drive

@param aLocalDrive Local drive logical channel abstraction

@pre Kernel must be unlocked
@pre Current thread in critical section

@post Kernel must be unlocked

@return KErrNone, if successful
		KErrNotFound, If no PDD matches criteria while getting driver list
		KErrNoMemory, If the array could not be expanded at some point while getting driver list or ran out of memory while opening media driver
		KErrNotReady, If not ready when trying to open media driver
		otherwise, one of the other system wide error codes.

@see DLocalDrive
*/
	{
	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_CONNECT_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Connect %O",iMediaId,aLocalDrive));
	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CONNECT, "iMediaId=%d; iDriveNumber=%d", iMediaId, aLocalDrive->iDrive->iDriveNumber );
	
	TInt r=KErrNone;
	
	if (iDfcQ)
		{
		TThreadMessage& m=Kern::Message();
		m.iValue=EConnect;
		m.iArg[0]=aLocalDrive;
		r=m.SendReceive(&iMsgQ);
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CONNECT_EXIT1, this, r );
		return r;
		}

	// If no DFC queue, must be a fixed media device
	// If this is the first connection, open media driver now
	// Assume no non-primary media exist on this device
	
	NKern::LockSystem();
	TBool first=iConnectionQ.IsEmpty();
	iConnectionQ.Add(&aLocalDrive->iMediaChangeObserver.iLink);
	NKern::UnlockSystem();
	if (first)
		{
		r=OpenMediaDriver();
		if (r!=KErrNone)
			{
			NKern::LockSystem();
			aLocalDrive->Deque();
			NKern::UnlockSystem();
			}
		}
	
	if (r==KErrNone)
		aLocalDrive->iDrive->iMedia=this;
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_CONNECT_EXIT2, this, r );
	return r;
	}




EXPORT_C void DPrimaryMediaBase::Disconnect(DLocalDrive* aLocalDrive)
/**
Disconnects from a local drive

@param aLocalDrive Local drive logical channel abstraction

@pre Kernel must be unlocked
@pre Current thread in critical section

@post Kernel must be unlocked
@see DLocalDrive
*/

	{
	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_DISCONNECT_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Disconnect %O",iMediaId,aLocalDrive));
	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_DISCONNECT, "iMediaId=%d; iDriveNumber=%d", iMediaId, aLocalDrive->iDrive->iDriveNumber );
	
	if (iDfcQ)
		{
		TThreadMessage& m=Kern::Message();
		m.iValue=EDisconnect;
		m.iArg[0]=aLocalDrive;
		m.SendReceive(&iMsgQ);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DISCONNECT_EXIT1, this );
		return;
		}

	// If no DFC queue, must be a fixed media device
	// If this is the last connection, close media driver now
	// Assume no non-primary media exist on this device
	DMediaDriver* pD=NULL;
	NKern::LockSystem();
	aLocalDrive->iDrive->iMedia=NULL;
	aLocalDrive->Deque();
	if (iConnectionQ.IsEmpty())
		{
		pD=iDriver;
		iDriver=NULL;
		}
	NKern::UnlockSystem();
	if (pD)
		pD->Close();
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DISCONNECT_EXIT2, this );
	}


/**
Connects a TLocDrv containing a media extension to the next primary media in the chain
*/
TInt DPrimaryMediaBase::Connect(TLocDrv* aLocDrv)
	{
	TInt r = KErrNone;

	NKern::LockSystem();
	TBool first = iConnectionQ.IsEmpty();
	iConnectionQ.Add(&aLocDrv->iMediaChangeObserver.iLink);
	NKern::UnlockSystem();

	if (first && !iDfcQ)
		{
		r = OpenMediaDriver();
		if (r!=KErrNone)
			{
			NKern::LockSystem();
			aLocDrv->iMediaChangeObserver.iLink.Deque();
			NKern::UnlockSystem();
			}
		}
	return r;
	}

TInt DPrimaryMediaBase::HandleMediaNotPresent(TLocDrvRequest& aReq)
	{
	TInt reqId = aReq.Id();

	if (reqId == DLocalDrive::ECaps)
		DefaultDriveCaps(*(TLocalDriveCapsV2*)aReq.RemoteDes());	// fill in stuff we know even if no media present

	TInt r = QuickCheckStatus();
	if (r != KErrNone && 
		reqId != DLocalDrive::EForceMediaChange &&			// EForceMediaChange, and 
		reqId != DLocalDrive::EReadPasswordStore &&			// Password store operations 
		reqId != DLocalDrive::EWritePasswordStore &&			// do not require the media 
		reqId != DLocalDrive::EPasswordStoreLengthInBytes)	// to be ready.)
 	 	{
		return r;
 	  	}

	return KErrNone;
	}

EXPORT_C TInt DPrimaryMediaBase::Request(TLocDrvRequest& aReq)
/**
Issues a local drive request. It is called from TLocDrv::Request() function .
Each local drive request is encapsulated as a TLocDrvRequest- a class derived from TThreadMessage, the kernel message class. 
TLocDrvRequest contains information pertaining to the request, including the ID and any associated parameters such as drive position, length and source/destination location.
Passes the request through to the media driver.

@param m Encapsulates the request information received from the client

@pre Enter with kernel unlocked

@post Leave with Kernel unlocked

@return KErrNone,if successful
	KErrBadDescriptor, if request encapsulates a bad descriptor
	Otherwise, one of the other system wide error codes.

@see TLocDrvRequest
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_REQUEST_ENTRY, this );

	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::Request(%08x)",iMediaId,&aReq));
	__KTRACE_OPT(KLOCDRV,Kern::Printf("this=%x, ReqId=%d, Pos=%lx, Len=%lx, remote thread %O",this,aReq.Id(),aReq.Pos(),aReq.Length(),aReq.RemoteThread()));

	OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_REQUEST, "reqId=%d; remote thread=0x%x", (TInt) aReq.Id(), (TUint) aReq.RemoteThread());
	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_REQUEST2, "length=%x:%x; position=%x:%x", (TUint) I64HIGH(aReq.Length()), (TUint) I64LOW(aReq.Length()), (TUint) I64HIGH(aReq.Pos()), (TUint) I64LOW(aReq.Pos()));
	
	TInt reqId = aReq.Id();

	TInt r = HandleMediaNotPresent(aReq);
	if (r != KErrNone)
		{
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT, this, r );
		return r;
		}

 	  	

	// for ERead & EWrite requests, get the linear address for pinning & DMA
	TUint8* linAddress = NULL;
	TClientBuffer clientBuffer;
	DThread* pT = NULL;

	if (reqId == DLocalDrive::ERead || reqId == DLocalDrive::EWrite)
		{
		pT = aReq.RemoteThread();
		if (!pT)
			pT = &Kern::CurrentThread();	// e.g. when using TBusLocalDrive directly

		// for silly zero-length requests, return immediately, setting the client 
		// descriptor length to zero if it's a read request
		if (aReq.Length() == 0)
			{
			DThread* pC = &Kern::CurrentThread();
			r = KErrNone;
			if (reqId == DLocalDrive::ERead)
				{
				TPtrC8 ptr(NULL, 0);
				r = Kern::ThreadDesWrite(pT, aReq.RemoteDes(), ptr, aReq.RemoteDesOffset(), KChunkShiftBy0,pC);
				}
			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT2, this, r );
			return r;
			}

		clientBuffer.SetFromDescriptor(aReq.RemoteDes(), pT);

		TInt length = 0;
		TInt maxLength = 0;
		TInt r = Kern::ThreadGetDesInfo(pT,aReq.RemoteDes(),length,maxLength,linAddress,EFalse);	// get descriptor length, maxlength and linAddress
		if (r != KErrNone)
		    {
			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT3, this, r );
			return r;
		    }
		linAddress+= aReq.RemoteDesOffset();

#ifdef __DEMAND_PAGING__
		// NB change in behavior IF DATA PAGING IS ENABLED: TLocDrvRequest::RemoteDes() points 
		// to a TClientBuffer rather than the client's remote descriptor
		if (DataPagingDeviceRegistered)
			{
			aReq.RemoteDes() = &clientBuffer;
			aReq.Flags() |= TLocDrvRequest::ETClientBuffer;
			}
#endif
		}

	if (iDfcQ)
		{
		__TRACE_TIMING(0x10);


#ifdef __DEMAND_PAGING__
		// If this is a ROM/Code paging media, pin writes 
		// If there is a Data paging media registered, pin all requests with descriptors 
		if ( (DataPagingDeviceRegistered) || (reqId == DLocalDrive::EWrite && RomPagingDfcQ(this)) )
		    {	    
			r = PinSendReceive(aReq, (TLinAddr) linAddress);
		    }
		else
#endif	// __DEMAND_PAGING__
			r = SendReceive(aReq, (TLinAddr) linAddress);
		}
	else
		{
		// If no DFC queue, must be a fixed media device
		// Media driver must already have been opened
		// Assume no non-primary media exist on this device
		// Just pass request straight through to media driver
		r = aReq.CheckAndAdjustForPartition();
		if (r == KErrNone)
			r = iDriver->Request(aReq);		
		}

#ifdef __DEMAND_PAGING__
		// NB change in behavior IF DATA PAGING IS ENABLED: TLocDrvRequest::RemoteDes() points 
		// to a TClientBuffer rather than the client's remote descriptor
	if (reqId == DLocalDrive::ERead && DataPagingDeviceRegistered && r == KErrNone)
		{
		r = clientBuffer.UpdateDescriptorLength(pT);
		}
#endif
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_REQUEST_EXIT4, this, r );
	return r;
	}


#ifdef __DEMAND_PAGING__
TInt DPrimaryMediaBase::PinSendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress)
	{
    OstTraceExt2(TRACE_FLOW, DPRIMARYMEDIABASE_PINSENDRECEIVE_ENTRY, "> DPrimaryMediaBase::PinSendReceive;aReq=%x;aLinAddress=%x;", (TUint) &aReq, (TUint) &aLinAddress );

	__ASSERT_DEBUG(ThePinObjectAllocator, LOCM_FAULT());


	TInt msgId = aReq.Id();
	TInt r;

	switch(msgId)
		{
		case DLocalDrive::EControlIO:
			{
			TInt controlIoType = aReq.Int3(); 
			switch(controlIoType)
				{
				case KLocalMessageHandle:
					// ControlIo is not supported if either of the two bare (TAny*) pointers are non-NULL 
					// as it's not possible to determine what the pointers are pointing at...
					if (aReq.Int1() || aReq.Int2())
						{
						__KTRACE_OPT(KDATAPAGEWARN, Kern::Printf("Data paging: Naked EControlIO not supported on paging device: fn=%x", aReq.Int0()));
						r = KErrNotSupported;
						break;
						}
					// fall into...
				case 0:
					r = SendReceive(aReq);
					break;

				default:
					// if Int3() is > 0, Int1() is a data pointer, and Int3() is a length
					if (controlIoType > (TInt) ThePinObjectAllocator->iFragmentGranularity)
					    {
						r = KErrTooBig;
						break;
					    }
					if (controlIoType < 0)
					    {
						r = KErrArgument;
						break;
					    }
					r = PinFragmentSendReceive(aReq, (TLinAddr) aReq.Ptr1(), controlIoType);
					break;
				}
			break;
			}

		case DLocalDrive::ERead:
		case DLocalDrive::EWrite:
			{
			r = PinFragmentSendReceive(aReq, aLinAddress, aReq.Length());
			break;
			}
		
		// For all these requests, aReq.RemoteDes() points to a buffer on the stack in DLocalDrive::Request()
		// This is a kernel stack & so should be unpaged & not require pinning...
		case DLocalDrive::ECaps:
		case DLocalDrive::EGetLastErrorInfo:
		case DLocalDrive::EQueryDevice:
		case DLocalDrive::EPasswordLock:
		case DLocalDrive::EPasswordUnlock:
		case DLocalDrive::EPasswordClear:
		case DLocalDrive::EReadPasswordStore:
		case DLocalDrive::EWritePasswordStore:
		case DLocalDrive::EPasswordStoreLengthInBytes:
		case DLocalDrive::EPasswordErase:

		default:		
			r = SendReceive(aReq);
		}
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_PINSENDRECEIVE_EXIT, this, r );
	return r;
	}

TInt DPrimaryMediaBase::PinFragmentSendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress, TInt aLength)
	{
	OstTraceExt3(TRACE_FLOW, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE_ENTRY, "> DPrimaryMediaBase::PinFragmentSendReceive;aReq=%x;aLinAddress=%x;aLength=%d;", (TUint) &aReq, (TUint) &aLinAddress, aLength );
	
	TLocDrvRequest fragment = aReq;		// create a request on the stack for use during fragmentation, pre-fill with the original req args, leave original Kernel message as repository (thread will block, message contents won't change)
	TInt r = KErrNone;

//	Kern::Printf(">PFSR %02X aReq %08X aLinAddress %08X aLen %08X offset %08X", aReq.Id(), &aReq, aLinAddress, aLength, aReq.RemoteDesOffset());

	DThread* pT = aReq.RemoteThread();
	if (!pT)
		pT=&Kern::CurrentThread();	// e.g. when using TBusLocalDrive directly

	__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Fragmenting Read/Write Request(0x%08x) on drive(%d), remote des(0x%x), offset into des(0x%x), original req Length(0x%x)",&aReq,aReq.Drive()->iDriveNumber,(TInt)(aReq.RemoteDes()),aReq.RemoteDesOffset(),aLength));
	__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Remote thread(0x%08x), current thread(0x%08x), start of data to write(0x%08x)",aReq.RemoteThread(),&Kern::CurrentThread(),(TInt)aLinAddress));
	OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE1, "Fragmenting Read/Write Request=0x%08x; drive=%d; remote des=0x%x; offset into des=0x%x; original length=0x%x", (TUint) &aReq, (TUint) aReq.Drive()->iDriveNumber, (TInt) (aReq.RemoteDes()), (TInt) aReq.RemoteDesOffset(), (TInt) aLength );
	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE2, "Remote Thread=0x%08x; current Thread=0x%x; start of data to write=0x%08x", (TUint) aReq.RemoteThread(), (TUint) &Kern::CurrentThread(),(TUint)aLinAddress );
	
	// don't want this thread to be terminated until last fragment is sent to MD and mem can be free'd up
	NKern::ThreadEnterCS();			

	__ASSERT_DEBUG(ThePinObjectAllocator, LOCM_FAULT());

	TUint fragmentGranularity = ThePinObjectAllocator->iFragmentGranularity;
	TInt dataLockResult = 0;
	// fragmentation only allowed for read/write requests
	__ASSERT_DEBUG(aLength <= (TInt) fragmentGranularity || (aReq.Id() == DLocalDrive::EWrite || aReq.Id() == DLocalDrive::ERead), LOCM_FAULT());

	// Pin the client buffer
	TInt pinnedLen;
	for (TInt pos = 0; pos < aLength; pos+= pinnedLen, aLinAddress+= pinnedLen)
		{
		pinnedLen = 0;

		// pin memory
		TInt remainingLen = aLength - pos; // remaining length

		// first attempt to pin memory with no pre-allocated buffers (which may fail)
		DPinObjectAllocator::SVirtualPinContainer* pinDataObject = ThePinObjectAllocator->AcquirePinObject();

		if (pinDataObject)
			{
			TInt lenToPin = Min(KMaxPinData, remainingLen);

			TInt r = Kern::PinVirtualMemory(pinDataObject->iObject, aLinAddress, lenToPin, pT);
			if (r == KErrNone)
				{
				pinnedLen = lenToPin;
				}
			else
				{
#ifdef __DEBUG_DEMAND_PAGING__
				Kern::Printf("Kern::PinVirtualMemory() error %d", r);
#endif
				// pin failed, so use preallocated buffer instead
				ThePinObjectAllocator->ReleasePinObject(pinDataObject);
				pinDataObject = NULL;
				}
			}

		if (!pinDataObject)
			{
			ThePinObjectAllocator->PreAllocatedDataLock().LockFragmentation();

			TLinAddr start = aLinAddress;
			do
				{
				TInt lenToPin = Min((TInt) fragmentGranularity, remainingLen - pinnedLen);

#ifdef __DEBUG_DEMAND_PAGING__
				Kern::Printf(">SR PinS Id %d aLinAddress %08X lenToPin %08X offset %08X", aReq.Id(), aLinAddress, lenToPin);
#endif

				dataLockResult = ThePinObjectAllocator->PreAllocatedDataLock().Lock(pT, start, lenToPin);

#ifdef __DEBUG_DEMAND_PAGING__
				Kern::Printf("<SR PinS Id %d aLinAddress %08X lenToPin %08X offset %08X r %d", aReq.Id(), aLinAddress, lenToPin, r);
#endif

				start+= lenToPin;
				pinnedLen+= lenToPin;
				}
			while (dataLockResult == 0 && pinnedLen < remainingLen);
			
			// if nothing pinned (dataLockResult == 0) or error (dataLockResult <0), release the mutex,
			// otherwise (dataLockResult > 0) release it after calling SendReceive()
			if (dataLockResult <= 0)
				ThePinObjectAllocator->PreAllocatedDataLock().UnlockFragmentation();

#ifdef __DEBUG_DEMAND_PAGING__
				if (dataLockResult < 0)
					Kern::Printf("DFragmentationPagingLock::Lock() %d", dataLockResult);			
#endif

			if (dataLockResult < 0)	// if lock returned an error then give up
				{
				r = dataLockResult;
				break;
				}
			}

		// fragment request Id defaults to same as original request
		fragment.Id() = aReq.Id();
		fragment.Length() = Int64(pinnedLen);
		fragment.RemoteDesOffset() = aReq.RemoteDesOffset() + pos;
		fragment.Pos() = aReq.Pos() + pos;
		fragment.Flags() = aReq.Flags();

		__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Send fragment (0x%08x) type(%d), length(0x%x), offset within original req(0x%x), pos in media(0x%lx)",&fragment,fragment.Id(), pinnedLen, pos, fragment.Pos()));
		OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE3, "Send fragment 0x%08x; type=%d; length=0x%x; offset within original req=0x%x", (TUint) &fragment, (TInt) fragment.Id(), (TUint) pinnedLen, (TUint) pos);
		OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE4, "Send fragment 0x%08x; position in media=%x:%x",(TUint) &fragment, (TUint) I64HIGH(fragment.Pos()), (TUint) I64LOW(fragment.Pos()));
		
#ifdef BTRACE_PAGING_MEDIA
		TInt buf[4];
		buf[0] = pinnedLen;	// fragment length
		buf[1] = pos;		// offset within original request
		buf[2] = fragment.Pos(); // offset in media
		buf[3] = (TInt)&pT->iNThread;	// thread that issued the original write req
		BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedFragmentBegin,&fragment,fragment.Id(),buf,sizeof(buf));
#endif
		r = SendReceive(fragment, aLinAddress);	// only come back here when message (fragment) has been completed
		
		// unpin memory
		if (pinDataObject)
			{
			Kern::UnpinVirtualMemory(pinDataObject->iObject);
			ThePinObjectAllocator->ReleasePinObject(pinDataObject);
			}
		else if (dataLockResult > 0)	// pinDataObject = NULL
			{
			__ASSERT_DEBUG(dataLockResult == 1, LOCM_FAULT());
			ThePinObjectAllocator->PreAllocatedDataLock().Unlock();
			ThePinObjectAllocator->PreAllocatedDataLock().UnlockFragmentation();
			}

#ifdef BTRACE_PAGING_MEDIA
		BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedFragmentEnd,&fragment,r);
#endif

		if (r != KErrNone)
			break;
		}

	NKern::ThreadLeaveCS();

//	Kern::Printf("<PFSR %02X aReq %08X aLinAddress %08X aLen %08X offset %08X", aReq.Id(), &aReq, aLinAddress, aLength, aReq.RemoteDesOffset());

	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_PINFRAGMENTSENDRECEIVE_EXIT, this, r );
	return r;
	}

#endif	// __DEMAND_PAGING__


TInt DPrimaryMediaBase::SendReceive(TLocDrvRequest& aReq, TLinAddr aLinAddress)
/**
 * If a Physical memory helper object is present for given drive,
 * then message is routed via helper;
 * 
 * @return KErrNone, if successful;
 * 		   otherwise, one of the other system wide error codes.
 * 
 * @see TLocDrvRequest::SendReceive()
 * @see DDmaHelper::SendReceive()
 */
	{
	OstTraceExt2( TRACE_FLOW, DPRIMARYMEDIABASE_SENDRECEIVE_ENTRY, "> DPrimaryMediaBase::SendReceive;aReq=%x;aLinAddress=%x", (TUint) &aReq, (TUint) &aLinAddress );
	
	DDmaHelper* dmaHelper = aReq.Drive()->iDmaHelper;

#ifdef __DEMAND_PAGING__
	RequestCountInc();
#endif

	TInt r;

	if (dmaHelper)
		r = dmaHelper->SendReceive(aReq, aLinAddress);
	else
	    { 
		r = aReq.SendReceive(&iMsgQ);
	    }
#ifdef __DEMAND_PAGING__
	RequestCountDec();
#endif

	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_SENDRECEIVE_EXIT, this, r );
	return r;
	}



EXPORT_C TInt DPrimaryMediaBase::ForceMediaChange(TInt)
/**
Forces a media change.The method can be overridden in the derived classes.
@param mode Media change mode

@return KErrNotSupported, in the default implementation
		KErrNone, if successful
		Otherwise, one of the other system wide error codes.

*/
	{
	// default implementation
	return KErrNotSupported;
	}

EXPORT_C TInt DPrimaryMediaBase::InitiatePowerUp()
/**
Initiates Power up sequence
@return KErrCompletion, operation is complete successfully or otherwise
		KErrNone, if successful
		Otherwise, one of the other system wide error codes.

*/
	{
	// default implementation, this is the default implementation.
	return KErrCompletion;
	}

EXPORT_C TInt DPrimaryMediaBase::QuickCheckStatus()
/**
Checks the status of the media device, whether the device is present,absent,not ready,etc.
The function can be overridden in the derived classes

@return KErrNone, if successful
		Otherwise, one of the other system wide error codes.

*/
	{
	// default implementation
	return KErrNone;
	}

EXPORT_C void DPrimaryMediaBase::DefaultDriveCaps(TLocalDriveCapsV2& aCaps)
/**
Fills in the default drive capabilities in TLocalDriveCapsV2 .
It initializes media type of drive as unknown and has to be overridden in the derived class. Called from the Request ( ) function of the same class.

@param aCaps Media drive capability fields. Extension to Capabilities fields(i.e) in addition to TLocalDriveCaps mainly to support Nor flash
@see TLocalDriveCapsV2
*/

	{
	// default implementation
	// aCaps is zeroed beforehand
	aCaps.iType = EMediaUnknown;
	}
	
EXPORT_C TBool DPrimaryMediaBase::IsRemovableDevice(TInt& /*aSocketNum*/)
/**
Checks whether it is a removable device or not
@param aSocketNum Socket number
@return ETrue=Removable Device
		EFalse=Non-Removable device, default implementation

*/
	{
	// default implementation
	return(EFalse);
	}

EXPORT_C void DPrimaryMediaBase::HandleMsg(TLocDrvRequest& m)
/**
It handles the drive request encapsulated in TLocDrvRequest depending on the message id.

@param aRequest Encapsulates the request information received from the client
@see TLocDrvRequest
*/
	{
	OstTrace1( TRACE_FLOW, DPRIMARYMEDIABASE_HANDLEMSG_ENTRY, "> DPrimaryMediaBase::HandleMsg;m=%x;", (TUint) &m);
	
	switch (m.iValue)
		{
		case EConnect:
			{
			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
			iConnectionQ.Add(&pD->iMediaChangeObserver.iLink);
			m.Complete(KErrNone, EFalse);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT1, this );
			return;
			}
		case EDisconnect:
			{
			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
			TLocDrv* pL=pD->iDrive;
			DMedia* media=pL->iMedia;
			if (iState==EReady && media && media->iDriver)
				media->iDriver->Disconnect(pD,&m);
			else
				{
				pD->Deque();
				m.Complete(KErrNone, EFalse);
				}
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT2, this );
			return;
			}
		case DLocalDrive::EForceMediaChange:
			{
			TUint flags = (TUint) m.Pos();

#ifdef __DEMAND_PAGING__
			// if this is a paging media (ROM,code or data), turn off the KMediaRemountForceMediaChange flag 
			// as this normally results in a call to DPBusSocket::ForceMediaChange() which effectively disables 
			// the media for a small time period - which would be disasterous if a paging request arrived
			if (iBody->iPagingDevice)
				flags&= ~KMediaRemountForceMediaChange;
#endif

			// For media extension drivers, send a copy of the request to the next drive in the chain and wait for it. 
			TLocDrv* drv = m.Drive();
			if (drv->iNextDrive)
				{
				TLocDrvRequest request;
				request.Drive() = drv->iNextDrive;
				request.Id() = DLocalDrive::EForceMediaChange;
				request.Pos() = m.Pos();	// flags

				request.SendReceive(&drv->iNextDrive->iPrimaryMedia->iMsgQ);

				CompleteRequest(m, request.iValue);
				return;
				}


			// if KForceMediaChangeReOpenDriver specified wait for power up, 
			// and then re-open this drive's media driver
			__KTRACE_OPT(KLOCDRV, Kern::Printf("EForceMediaChange, flags %08X\n", flags));
			if (flags == (TUint) KForceMediaChangeReOpenMediaDriver)
				{
				TInt sock;
				if (!IsRemovableDevice(sock))
					{
					CompleteRequest(m, KErrNotSupported);
					OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT3, this );
					return;
					}
				// wait for power up and then call DPrimaryMediaBase::DoRequest()
				break;
				}

			TInt r=ForceMediaChange(flags);
			if (r==KErrNone)
				{
				// wait for media change notification to complete message
				m.Forward(&iWaitMedChg,EFalse);
				}
			else
				{
				if (r==KErrNotSupported || r==KErrCompletion)
					r=KErrNone;
				CompleteRequest(m, r);
				}
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT4, this );
			return;
			}
		case DLocalDrive::ECaps:
			if (iState==EPoweredDown)
				{
				// The media is powered down, but the media driver still exists.
				//  - Issue the ECaps request without powering the media back up.
				DoRequest(m);
				__TRACE_TIMING(0x101);
				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT5, this );
				return;
				}
			break;

		case DLocalDrive::ERead:
		case DLocalDrive::EWrite:
		case DLocalDrive::EFormat:
		case DLocalDrive::EEnlarge:
		case DLocalDrive::EReduce:
		case DLocalDrive::EPasswordLock:
		case DLocalDrive::EPasswordUnlock:
		case DLocalDrive::EPasswordClear:
		case DLocalDrive::EPasswordErase:
		case DLocalDrive::EControlIO:
		case DLocalDrive::EDeleteNotify:
		case DLocalDrive::EQueryDevice:

#ifdef __DEMAND_PAGING__
		case DMediaPagingDevice::ERomPageInRequest:
		case DMediaPagingDevice::ECodePageInRequest:
#endif
			break;
		case DLocalDrive::EGetLastErrorInfo:
			{
			DLocalDrive* pD=(DLocalDrive*)m.Ptr0();
			TLocDrv* pL=pD->iDrive;
			*((TErrorInfo*) m.RemoteDes()) = pL->iLastErrorInfo;
			CompleteRequest(m, KErrNone);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT6, this );
			return;
			}
		case DLocalDrive::EReadPasswordStore:
			{
			TPtr8 pswData ((TUint8*) m.RemoteDes(), (TInt) m.Length());
			TInt r = ThePasswordStore->ReadPasswordData(pswData);
			m.Length() = pswData.Length();
			CompleteRequest(m, r);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT7, this );
			return;
			}
		case DLocalDrive::EWritePasswordStore:
			{
			TPtrC8 pData((TUint8*) m.RemoteDes(), (TInt) m.Length());
			TInt r = ThePasswordStore->WritePasswordData(pData);

			if(r != KErrNone)
				{
				CompleteRequest(m, r);
				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT8, this );
				return;
				}

			r = QuickCheckStatus();
			if(r != KErrNone)
				{
				// Don't try to power up the device if it's not ready.
				// - Note that this isn't an error that needs to be returned to the client.
				CompleteRequest(m, KErrNone);
				OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT9, this );
				return;
				}

			break;
			}
		case DLocalDrive::EPasswordStoreLengthInBytes:
			{
			TInt length = ThePasswordStore->PasswordStoreLengthInBytes();
			*(TInt*) m.RemoteDes() = length;
			CompleteRequest(m, KErrNone);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT10, this );
			return;
			}
		default:
			CHECK_RET(KErrNotSupported);
			CompleteRequest(m, KErrNotSupported);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT11, this );
			return;
		}

	__KTRACE_OPT(KFAIL,Kern::Printf("mdrq %d",m.Id()));
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::HandleMsg(%08X) state %d req %d",iMediaId,&m,iState,m.Id()));

	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_HANDLEMSG2, "iMediaId=%d; iState=%d; req Id=%d", iMediaId, iState, m.Id());
	
	// if media driver already open, pass request through
	if (iState==EReady)
		{
		DoRequest(m);
		__TRACE_TIMING(0x101);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT12, this );
		return;
		}

	// if open or close in progress, defer this message
	if (iState!=EClosed && iState!=EPoweredDown)
		{
#ifdef __DEMAND_PAGING__
		if (DMediaPagingDevice::PagingRequest(m))
			{
			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
			__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());

			__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Deferring PageIn request 0x%08x because opening or closing",&m));
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_HANDLEMSG3, "Deferring PageIn request 0x%08x because opening or closing", &m);
			iBody->iPagingDevice->SendToDeferredQ(&m);
			}
		else
#endif
		m.Forward(&iDeferred,EFalse);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT13, this );
		return;
		}

	// nothing is open, so try to open something
	__ASSERT_ALWAYS(!iCurrentReq,LOCM_FAULT());

#ifdef __DEMAND_PAGING__

#ifdef BTRACE_PAGING_MEDIA
	if (DMediaPagingDevice::PagingRequest(m))
		BTraceContext12(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInQuietlyDeferred,&m,iState,m.iValue);
#endif	// BTRACE_PAGING_MEDIA

#ifdef _DEBUG
	__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());

	if (DMediaPagingDevice::PagingRequest(m))
		{
		__ASSERT_DEBUG(iPagingMedia,LOCM_FAULT());
		__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
		__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Page request 0x%08x received -> opening MD",&m));
		OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_HANDLEMSG4, "Page request 0x%08x received; opening MD", &m);
		}
#endif	// _DEBUG

#endif	// __DEMAND_PAGING__

	iCurrentReq=&m;
	if(iState == EClosed)
		{
		iState=EPoweringUp1;
		}
	else if (iState == EPoweredDown)
		{
		iState=EPoweringUp2;
		}

	TInt r=InitiatePowerUp();
	if (r==KErrNone || r==KErrServerBusy)
		{
		// wait for completion of power up request
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT14, this );
		return;
		}
	if (r==KErrCompletion)
		r=KErrNone;		// device already powered up
	PowerUpComplete(r);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_HANDLEMSG_EXIT15, this );
	}

EXPORT_C TInt DPrimaryMediaBase::DoRequest(TLocDrvRequest& m)
/**
If the media exists, it tries to get the partition information if not there. 
It then passes on the request to the media driver by calling its Request( ) function. 
Then it completes the kernel thread message and the reference count of the thread is closed asynchronously.

@param aRequest Encapsulates the request information received from the client

@return KErrNone, if successful
	KErrNotReady, if missing partitions on removable media
	KErrNotSupported, if missing partitions on fixed media
	KErrArgument Out of range argument ,encapsulated in Local drive request , passed while checking and adjusting for partition
	KErrEOF, Reached the end of file
	KErrBadDescriptor, if request encapsulates a bad descriptor
	Otherwise, one of the other system wide error codes.

*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOREQUEST_ENTRY, this );
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DPrimaryMediaBase(%d)::DoRequest(%08X) req %d", iMediaId, &m, m.Id()));
	TLocDrv* pL=m.Drive();
	DMedia* media=pL->iMedia;
	TInt r=KErrNone;
	
	OstTraceDefExt5( OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_DOREQUEST, "req Id=%d; length=%x:%x; position=%x:%x", (TInt) m.Id(), (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()) );
	
	// re-open this drive's media driver ?
	if (m.iValue == DLocalDrive::EForceMediaChange)
		{
		__ASSERT_DEBUG(((TUint) m.Pos()) == (TUint) KForceMediaChangeReOpenMediaDriver, LOCM_FAULT());
		iCurrentReq=NULL;

		TLocDrv* pL = m.Drive();
		DMedia* media = pL->iMedia;

		if (media && media->iDriver)
			CloseMediaDrivers(media);

		iState=EOpening;
		StartOpenMediaDrivers();

		NotifyClients(EMediaChange, pL);
		CompleteRequest(m, r);
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT, this, r );
		return r;
		}

	if (!media || !media->iDriver || iState == EClosed)
		{
		// Return KErrNotReady for missing partitions on removable media
		// as opposed to KErrNotSupported for missing partitions on fixed media
		// since the latter don't exist whereas the former might exist at some time.
		TInt sock;
		r=IsRemovableDevice(sock) ? KErrNotReady : KErrNotSupported;
		}

	iCurrentReq=&m;
	if (r==KErrNone)
		{
		if(iTotalPartitionsOpened == 0)
			{
			UpdatePartitionInfo();
			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT2, this, KErrNone );
			return KErrNone;
			}
		if (!(m.Flags() & TLocDrvRequest::EAdjusted))
			{
			// If this isn't the only partition, don't allow access to the whole media 
			if (TDriveIterator::GetPhysicalDrive(m.Drive())->iPrimaryMedia->iTotalPartitionsOpened > 1)
				m.DriverFlags() &= ~RLocalDrive::ELocDrvWholeMedia;
			r=m.CheckAndAdjustForPartition();
			}
		if (r==KErrNone)
			{
			OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_INTERNALS, DPRIMARYMEDIABASE_DOREQUEST_START, "req Id=%d; Remote Thread=0x%x", (TInt) m.Id(), (TUint) m.RemoteThread());
			r=media->iDriver->Request(m);
			if (r>0)
				{
				// defer request
#ifdef __DEMAND_PAGING__
				if (DMediaPagingDevice::PagingRequest(m))
					{
					__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
					__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
					__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
					__KTRACE_OPT2(KLOCDPAGING,KLOCDRV,Kern::Printf("Defer PageIn request 0x%08x",&m));
					OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST2, "Defer PageIn request 0x%08x", &m);
					DMediaPagingDevice* pagingdevice=iBody->iPagingDevice; 

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
					TInt id=m.iValue;
					if (id==DMediaPagingDevice::ERomPageInRequest)
						{
						NKern::FMWait(&pagingdevice->iInstrumentationLock);
						if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EDeferredQ)
							pagingdevice->iROMStats.iTotalReDeferrals++;
						else if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EMainQ)
							pagingdevice->iROMStats.iTotalSynchDeferredFromMainQ++;
						NKern::FMSignal(&pagingdevice->iInstrumentationLock);
						}
					else if (m.Flags() & TLocDrvRequest::ECodePaging)
						{
						NKern::FMWait(&pagingdevice->iInstrumentationLock);
						if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EDeferredQ)
							pagingdevice->iCodeStats.iTotalReDeferrals++;
						else if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EMainQ)
							pagingdevice->iCodeStats.iTotalSynchDeferredFromMainQ++;
						NKern::FMSignal(&pagingdevice->iInstrumentationLock);
						}
					else if (m.Flags() & TLocDrvRequest::EDataPaging)
						{
						NKern::FMWait(&pagingdevice->iInstrumentationLock);
						if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EDeferredQ)
							pagingdevice->iDataStats.iTotalReDeferrals++;
						else if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EMainQ)
							pagingdevice->iDataStats.iTotalSynchDeferredFromMainQ++;
						NKern::FMSignal(&pagingdevice->iInstrumentationLock);
						}
#endif
					pagingdevice->SendToDeferredQ(&m);
					}
				else
#endif
					m.Forward(&iDeferred,EFalse);
				r=KErrNone;
				}
#if defined(__DEMAND_PAGING__) && defined(_DEBUG)
			else if (r == KErrNone && DMediaPagingDevice::PagingRequest(m))
			    {
				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("PageIn req 0x%08x completing asynchronously",&m));
                OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST3, "PageIn req 0x%08x completing asynchronously", &m);
			    }
#endif
			}
		}

	if (r!=KErrNone && iCurrentReq)
		{
		TInt s=(r==KErrCompletion)?KErrNone:r;
		CHECK_RET(s);

#ifdef __DEMAND_PAGING__
		// got here because media driver cannot service or defer this request or did service it synchronously
		if (DMediaPagingDevice::PagingRequest(m))
			{
			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
			__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("media driver cannot service or defer PageIn request 0x%08x or serviced it synchronously (%d)",&m, s));
			OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOREQUEST4, "Media driver cannot service or defer PageIn request 0x%08x or serviced it synchronously; retval=%d",(TUint) &m, s);
			iBody->iPagingDevice->CompleteRequest(&m, s);
			}
		else
#endif
			{
			CompleteRequest(m, s);
			OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_INTERNALS, DPRIMARYMEDIABASE_DOREQUEST_RETURN, "Return Remote Thread=0x%x; retval=%d", (TUint) m.RemoteThread(), (TInt) s);
			}
		}

	iCurrentReq=NULL;
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_DOREQUEST_EXIT3, this, r );
	return r;
	}

EXPORT_C void DPrimaryMediaBase::PowerUpComplete(TInt anError)
/**
Called after the device is powered up or there is some error while powering up the device. 
If there is an error powering up the devices then it just completes the current running requests with an error 
and also completes the outstanding requests on the iDeferred message queue by calling SetClosed( ).
If the device is powered up OK then it either opens the media drivers 
and if they are already open then it handles the current/pending requests.

@param anError Error code to be passed on while completing outstanding requests.
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase(%d)::PowerUpComplete err %d iState %d",iMediaId,anError,iState));
	
	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_POWERUPCOMPLETE, "iMediaId=%d; anError=%d; iState=%d", iMediaId, anError, iState );
	
	if (anError!=KErrNone)
		{
		// error powering up device
		if (iState==EPoweringUp1 || iState==EPoweringUp2)
			SetClosed(anError);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_EXIT, this );
		return;
		}

	// Powered up OK - now open media drivers
	if (iState==EPoweringUp1)
		{
		iState=EOpening;
		StartOpenMediaDrivers();
		}
	else if (iState==EPoweringUp2)
		{
		// media is powered up and ready, so handle the current/pending requests
		MediaReadyHandleRequest();
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_POWERUPCOMPLETE_EXIT2, this );
	}

void DPrimaryMediaBase::CloseMediaDrivers(DMedia* aMedia)
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase(%d)::CloseMediaDrivers",iMediaId));
	OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS1, "DPrimaryMediaBase iMediaId=%d", iMediaId );
	
	// we mustn't ever close the media driver if it's responsible for data paging as re-opening the drive
	// would involve memory allocation which might cause deadlock if the kernel heap were to grow
#ifdef __DEMAND_PAGING__
	if (DataPagingMedia(this))
		{
		__KTRACE_OPT(KLOCDRV,Kern::Printf("CloseMediaDrivers aborting for data paging media %08X", this));
		OstTrace1(TRACE_FLOW, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_EXIT1, "CloseMediaDrivers aborting for data paging media 0x%08x", this);
		return;
		}
#endif


	// Don't close any media extension drivers either, since it won't serve any purpose
	// and keeping the driver open allows it to maintain internal state
	if (iBody->iMediaExtension)
		{
		__KTRACE_OPT(KLOCDRV,Kern::Printf("CloseMediaDrivers aborting for extension media %08X", this));
		return;
		}


	TDriveIterator driveIter;
	for (TLocDrv* pL = driveIter.NextDrive(); pL != NULL; pL = driveIter.NextDrive())
		{
		if (pL && pL->iPrimaryMedia==this)
			{
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d",driveIter.Index()));
			OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS2, "Drive=%d", driveIter.Index());
			if (aMedia == NULL || pL->iMedia == aMedia)
				{
				pL->iMedia=NULL;
				}
			}
		}
	for (TInt i=iLastMediaId; i>=iMediaId; i--)
		{
		DMedia* pM=TheMedia[i];
		if (aMedia == NULL || pM == aMedia)
			{
			DMediaDriver* pD=pM->iDriver;
			pM->iDriver=NULL;
			__KTRACE_OPT(KLOCDRV,Kern::Printf("DMedia[%d] @ %08x Driver @ %08x",i,pM,pD));
			OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS3, "MediaId=%d; DMedia=0x%08x; MediaDriver=0x%08x", (TInt) i, (TUint) pM, (TUint) pD );
			if (pD)
				pD->Close();
			}
		}
	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DPrimaryMediaBase(%d)::CloseMediaDrivers",iMediaId));
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_CLOSEMEDIADRIVERS_EXIT2, this );
	}

void DPrimaryMediaBase::StartOpenMediaDrivers()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::StartOpenMediaDrivers",iMediaId));
	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS, "DPrimaryMediaBase iMediaId=%d ",iMediaId);
	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);

	// Get a list of all currently loaded media drivers
	// Most media drivers do not make use of the pointer iMountInfo.iInfo when 
	// their Validate() procedures are called from RPhysicalDeviceArray::GetDriverList(). 
	// However, a group of media drivers sharing the same id (passed in iDevice) may use 
	// the additional information pointed to by iMountInfo.iInfo to distinguish 
	// group members. This information is passed when the media driver is registered 
	// using LocDrv::RegisterMediaDevice().
	TInt r=iPhysDevArray.GetDriverList(KLitMediaDriverName,iDevice,iMountInfo.iInfo,ver);
	if (r!=KErrNone)
		{
		// out of memory or no driver exists
		SetClosed(r);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_EXIT1, this );
		return;
		}

	// Go through them starting with highest priority
	iNextMediaId=iMediaId;
	iBody->iPhysDevIndex=iPhysDevArray.Count()-1;
	iTotalPartitionsOpened=0;
	iMediaDriversOpened=0;
	iNextMediaDriver=NULL;
	OpenNextMediaDriver();
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_STARTOPENMEDIADRIVERS_EXIT2, this );
	}

void DPrimaryMediaBase::OpenNextMediaDriver()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::OpenNextMediaDriver, this %x mediaId %d iBody->iPhysDevIndex %d",iNextMediaId, this, iMediaId, iBody->iPhysDevIndex));
	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER, "DPrimaryMediaBase iNextMediaId=%d; this=%x; imediaId=%d; iBody->iPhysDevIndex=%d",iNextMediaId, (TUint) this, iMediaId, iBody->iPhysDevIndex);
	
	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
	SPhysicalDeviceEntry& e=iPhysDevArray[iBody->iPhysDevIndex];
	DPhysicalDevice* pD=e.iPhysicalDevice;

	iState = EOpening;

	DMedia* pM=TheMedia[iNextMediaId];
	if (pM && pM->iDriver != NULL)
		{
		iNextMediaDriver = pM->iDriver;
		DoOpenMediaDriverComplete(KErrNone);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_EXIT1, this );
		return;
		}

	// this may be asynchronous
	TInt s=pD->Create( (DBase*&)iNextMediaDriver, iMediaId,  (TDesC8*) &iMountInfo, ver);
	
	__KTRACE_OPT(KLOCDRV,Kern::Printf("Media:Open-Opening %o(PRI:%d)-%d",pD,e.iPriority,s));
	if (s!=KErrNone)
		{
		iAsyncErrorCode=s;
		iAsyncDfc.Enque();
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_OPENNEXTMEDIADRIVER_EXIT2, this );
	}

// Called when a media driver has responded to the Open request
void DPrimaryMediaBase::DoOpenMediaDriverComplete(TInt anError)
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::DoOpenMediaDriverComplete error %d iNextMediaDriver %x",iNextMediaId,anError,iNextMediaDriver));
    OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE, "iMediaId=%d; anError=%d; iNextMediaDriver=0x%x", (TInt) iNextMediaId, (TInt) anError, (TUint) iNextMediaDriver);

	
	if (anError!=KErrNone)
		{
		DMediaDriver* md = iNextMediaDriver;
		iNextMediaDriver = NULL;
		if (md)
			md->Close();
		}
	if (anError==KErrNotReady || anError==KErrNoMemory)
		{
		// if it's not ready or we're out of memory, abort
		CloseMediaDrivers();
		SetClosed(anError);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_EXIT1, this );
		return;
		}
	if (anError==KErrNone)
		{
		DMedia* pM=TheMedia[iNextMediaId];
		pM->iDriver=iNextMediaDriver;
		DPhysicalDevice*& pD=iPhysDevArray[iBody->iPhysDevIndex].iPhysicalDevice;
		iNextMediaDriver->iPhysicalDevice=pD;
		pD=NULL;	// so it won't be closed when we tidy up
		++iMediaDriversOpened;
		}

	
	// if no error, read partition info on media
	iState = EReadPartitionInfo;

	if (anError == KErrNone)
		{
		DMedia* pM=TheMedia[iNextMediaId];
		TInt r = pM->iDriver->PartitionInfo(pM->iPartitionInfo);
		if (r!=KErrNone)
			{
			if (r==KErrCompletion)
				r=KErrNone;
			DoPartitionInfoComplete(r);
			}
		}
	else
		{
		DoPartitionInfoComplete(anError);
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOOPENMEDIADRIVERCOMPLETE_EXIT2, this );
	}

void DPrimaryMediaBase::DoPartitionInfoComplete(TInt anError)
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::DoPartitionInfoComplete error %d",iNextMediaId,anError));

	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE1, "iNextMediaId=%d; anError=%d", iNextMediaId, anError );
	
	DMedia* pM=TheMedia[iNextMediaId];
	if (anError==KErrNone || anError == KErrLocked)
		{
		// successfully read partition info
		iTotalPartitionsOpened+=pM->PartitionCount();
		}
	else
		{
		// couldn't read partition info or driver failed to open
		if (pM->iDriver)
			{
#ifdef __DEMAND_PAGING__
			if (DataPagingMedia(this))
				{
				__KTRACE_OPT(KLOCDRV,Kern::Printf("DoPartitionInfoComplete() Close Media Driver aborted for data paging media %08X", this));
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE2, "Close Media Driver for data paging media 0x%08x", this);
				}
			else
#endif
			if (iBody->iMediaExtension)
				{
				__KTRACE_OPT(KLOCDRV,Kern::Printf("DoPartitionInfoComplete() Close Media Driver aborted for extension media %08X", this));
				}
			else
				{
				pM->iDriver->Close();
				pM->iDriver=NULL;
				}
			}
		if (anError==KErrNotReady || anError==KErrNoMemory)
			{
			// if it's not ready or we're out of memory, or the drive is locked, abort
			CloseMediaDrivers();
			SetClosed(anError);
			OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT, this );
			return;
			}
		}

	// Open next media driver, if there is one
	TBool complete = EFalse;
	if (++iNextMediaId>iLastMediaId)
		complete=ETrue;
	if (iBody->iPhysDevIndex==0)
		complete=ETrue;
	else
		iBody->iPhysDevIndex--;
	if (!complete)
		{
		OpenNextMediaDriver();
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT2, this );
		return;
		}

	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase %d All media drivers open & partitions read",iMediaId));
	__KTRACE_OPT(KLOCDRV,Kern::Printf("%d media drivers opened",iMediaDriversOpened));
	OstTrace1( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE3, "iMediaDriversOpened=%d", iMediaDriversOpened );
	if (iMediaDriversOpened==0)
		{
		SetClosed(KErrNotSupported);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT3, this );
		return;
		}

	// we are now finished with media driver list
	iPhysDevArray.Close();

	// Finished reading partition info
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase %d Read partition info complete",iMediaId));
	__KTRACE_OPT(KLOCDRV,Kern::Printf("%d total partitions",iTotalPartitionsOpened));
	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE4, "Read partition info complete iMediaId=%d; iPartitionsOpened=%d", iMediaId, iTotalPartitionsOpened );
	if (iTotalPartitionsOpened==0)
		{
		SetClosed(KErrNotSupported);
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT4, this );
		return;
		}
	
	// work out mapping of drives to partitions/media
	TInt totalPartitions=iTotalPartitionsOpened;
	TInt id=iMediaId;	// start with primary media
	TInt partitionsOnThisMedia=PartitionCount();
	TInt partition=0;

	TDriveIterator driveIter;
	for (TLocDrv* pD = driveIter.NextDrive(); pD != NULL; pD = driveIter.NextDrive())
		{
		if (pD && pD->iPrimaryMedia==this)
			{
			if (totalPartitions==0)
				{
				pD->iMedia=NULL;
				continue;
				}
			if (partition==partitionsOnThisMedia)
				{
				id++;
				partition=0;
				partitionsOnThisMedia=TheMedia[id]->PartitionCount();
				}
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d = Media %d Partition %d",driveIter.Index(),id,partition));
			OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE5, "Local Drive=%d; iMediaId=%d; partition=%d", driveIter.Index(), id, partition );
			pD->iMedia=TheMedia[id];
			pD->iPartitionNumber=partition;
			memcpy(pD, pD->iMedia->iPartitionInfo.iEntry+partition, sizeof(TPartitionEntry));
			partition++;
			totalPartitions--;
			}
		}

	// media is now ready - handle current or deferred requests
	MediaReadyHandleRequest();
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_DOPARTITIONINFOCOMPLETE_EXIT5, this );
	}

void DPrimaryMediaBase::MediaReadyHandleRequest()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_MEDIAREADYHANDLEREQUEST_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase::MediaReadyHandleRequest() this %x", this));
	iState = EReady;

	// now we can process the current request
	// careful - thread may have exited while we were powering up
	if (iCurrentReq)
		{
		DoRequest(*iCurrentReq);	// this sets iCurrentReq=NULL
		}

	// see if we can process any other requests concurrently
	RunDeferred();
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_MEDIAREADYHANDLEREQUEST_EXIT, this );
	}

void DPrimaryMediaBase::UpdatePartitionInfo()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_UPDATEPARTITIONINFO_ENTRY, this );
	iState=EReadPartitionInfo;
	iNextMediaId=iMediaId;
	DMedia* pM=TheMedia[iNextMediaId];
	TInt r=pM->iDriver->PartitionInfo(pM->iPartitionInfo);
	if (r!=KErrNone)
		{
		if (r==KErrCompletion)
			r=KErrNone;
		DoPartitionInfoComplete(r);
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_UPDATEPARTITIONINFO_EXIT, this );
	}

void DPrimaryMediaBase::CompleteCurrent(TInt anError)
	{
	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_COMPLETECURRENT_ENTRY, this );
	if (iCurrentReq)
		{
		CHECK_RET(anError);
#ifdef __DEMAND_PAGING__
		// got here because it was powered down when powering up, or failed powering up or failed opening MD or got media change
		if (DMediaPagingDevice::PagingRequest(*iCurrentReq))
			{
			__ASSERT_ALWAYS(iPagingMedia,LOCM_FAULT());
			__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
			__ASSERT_ALWAYS( ((iCurrentReq->Flags() & TLocDrvRequest::ECodePaging) == 0) || (iCurrentReq->Drive()->iPagingDrv), LOCM_FAULT());

			__KTRACE_OPT2(KLOCDPAGING,KFAIL,Kern::Printf("Got here because it was powered down when powering up, or failed powering up or failed opening MD or got media change"));
			OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_COMPLETECURRENT, "Completed request due to powered down when powering up, or failed powering up or failed opening MD or got media change");
			iBody->iPagingDevice->CompleteRequest(iCurrentReq, anError);
			}
		else
#endif
		CompleteRequest(*iCurrentReq, anError);
		iCurrentReq=NULL;
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_COMPLETECURRENT_EXIT, this );
	}


void DPrimaryMediaBase::CompleteRequest(TLocDrvRequest& aMsg, TInt aResult)
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_COMPLETEREQUEST_ENTRY, this );
	OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_REQUEST, DPRIMARYMEDIABASE_COMPLETEREQUEST1, "TLocDrvRequest Object=0x%x; aResult=%d", (TUint) &aMsg, aResult);


	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::CompleteRequest(%08x) r %d",iMediaId,&aMsg, aResult));

	aMsg.Complete(aResult,EFalse);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_COMPLETEREQUEST_EXIT, this );
	}

EXPORT_C void DPrimaryMediaBase::RunDeferred()
/**
Runs deferred Requests. Initiated from DPrimaryMediaBase::PowerUpComplete() function 
to see if any other requests can be processed concurrently. 
Can also be called from DPrimaryMediaBase::NotifyPowerDown 
or DPrimaryMediaBase::NotifyEmergencyPowerDown() function or DMediaDriver::Complete()
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_RUNDEFERRED_ENTRY, this );
	// Do nothing if an open or close is in progress - this might be the case, for example, 
	// if a EForceMediaChange request (with the  KForceMediaChangeReOpenMediaDriver flag) 
	// has recently been processed
	if (iState!=EReady && iState!=EClosed && iState!=EPoweredDown)
	    {
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT1, this );
		return;
	    }
	
	// rerun deferred requests;
#ifdef __DEMAND_PAGING__
#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	TInt countROM=0;
	TInt countCode=0;
#endif

	if(iPagingMedia)
		{
		__ASSERT_DEBUG(iBody->iPagingDevice,LOCM_FAULT());
		if(iBody->iPagingDevice->iEmptyingQ & DMediaPagingDevice::EDeferredQ)		// if already emptying deferred page in queue, don't reenter
			{
			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Already emptying deferred queue"));
			OstTrace0(TRACE_FLOW, DPRIMARYMEDIABASE_RUNDEFERRED_EXIT2, "< Already emptying deferred queue");
			return;
			}

		DMediaPagingDevice* pagingdevice=iBody->iPagingDevice;
		TLocDrvRequest* pL = (TLocDrvRequest*) pagingdevice->iDeferredQ.Last();
		if(pL)
			{
			pagingdevice->iEmptyingQ|= DMediaPagingDevice::EDeferredQ;			// prevent reentering when already emptying this queue
			TLocDrvRequest* pM=NULL;
			while (pM != pL && (pM = (TLocDrvRequest*) pagingdevice->iDeferredQ.Poll()) != NULL)	// synchronously empty deferred queue but ignore re-deferrals
				{
				__ASSERT_ALWAYS( DMediaPagingDevice::PagingRequest(*pL), LOCM_FAULT() );

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
				(pM->iValue==DMediaPagingDevice::ERomPageInRequest)?(countROM++):(countCode++);
				if(pM==pL)
					{
					NKern::FMWait(&pagingdevice->iInstrumentationLock);
					if(pM->iValue==DMediaPagingDevice::ERomPageInRequest && pagingdevice->iROMStats.iMaxReqsInDeferred<countROM)
						pagingdevice->iROMStats.iMaxReqsInDeferred=countROM;
					else if ((pM->Flags() & TLocDrvRequest::ECodePaging) && pagingdevice->iCodeStats.iMaxReqsInDeferred<countCode)
							pagingdevice->iCodeStats.iMaxReqsInDeferred=countCode;
					else if ((pM->Flags() & TLocDrvRequest::EDataPaging) && pagingdevice->iDataStats.iMaxReqsInDeferred<countCode)
							pagingdevice->iDataStats.iMaxReqsInDeferred=countCode;
					NKern::FMSignal(&pagingdevice->iInstrumentationLock);
					}
#endif
				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("RunDeferred: process req 0x%08x, last in deferred queue 0x%08x",pM,pL));
				OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_RUNDEFERRED2, "process req=0x%08x; last in deferred queue=0x%08x",(TUint) pM, (TUint) pL);
#ifdef BTRACE_PAGING_MEDIA
				BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInDeferredReposted,pM,pM->iValue);
#endif
				// if Page In requests are synchronous this services them all in sequence, 
				// if they're asynch it re-defers them
				DoRequest(*(TLocDrvRequest*)pM);	
				}
			pagingdevice->iEmptyingQ&= ~DMediaPagingDevice::EDeferredQ;
			}

		// the reason we now try an empty the main Page In queue is there is at least one type of Page In request 
		// serviced synchronously in which case when we empty the deferred Page In queue as above, received Page In 
		// requests are left in the main queue (not deferred) and we don't want to start processing deferred normal 
		// requests before these Page In requests. If all deferred normal requests are synchronous, the received Page 
		// In requests will have to wait until all are serviced. NB: requests may be deferred even if the MD services 
		// all requests synchronously, but runs background tasks that cannot be interrupted. In this last case the 
		// normal deferred queue may have some very long latency requests.
		if(pagingdevice->iEmptyingQ & DMediaPagingDevice::EMainQ)	// already emptying main Page In queue, skip (any Page In requests will be deferred)
			{
			__KTRACE_OPT(KLOCDPAGING,Kern::Printf("Already emptying main queue"));
			OstTrace0(TRACE_FLOW, DPRIMARYMEDIABASE_RUNDEFERRED_EXIT3, "< Already emptying main queue");
			return;
			}
	
		TLocDrvRequest* pM=NULL;
		if (!pagingdevice->iMainQ.iReady)	// if it's ready, then queue is empty
			{
			pM = (TLocDrvRequest*) pagingdevice->iMainQ.iMessage;
			pagingdevice->iMainQ.iMessage = NULL;
			if (pM == NULL)
				pM = (TLocDrvRequest*) pagingdevice->iMainQ.Poll();
			}

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
		countROM = countCode=0;
#endif
		if(pM)
			{
#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
			__e32_atomic_add_ord32(&pagingdevice->iROMStats.iTotalSynchEmptiedMainQ, 1);
#endif
			pagingdevice->iEmptyingQ|=DMediaPagingDevice::EMainQ;
			for ( ; pM != NULL; pM = (TLocDrvRequest*) pagingdevice->iMainQ.Poll())
				{
				__ASSERT_ALWAYS(DMediaPagingDevice::PagingRequest(*pM), LOCM_FAULT());

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
				(pM->iValue==DMediaPagingDevice::ERomPageInRequest)?(countROM++):(countCode++);
#endif

				__KTRACE_OPT(KLOCDPAGING,Kern::Printf("RunDeferred: process req 0x%08x",pM));
				OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_RUNDEFERRED4, "process req=0x%08x", pM);
				DoRequest(*(TLocDrvRequest*)pM);	// if Page In requests are synchronous this services them all in sequence, if they're asynch it defers them
				}

			pagingdevice->iEmptyingQ&= ~DMediaPagingDevice::EMainQ;


#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
			NKern::FMWait(&pagingdevice->iInstrumentationLock);
			pagingdevice->iROMStats.iTotalSynchServicedFromMainQ+=countROM;
			if(pagingdevice->iROMStats.iMaxReqsInPending<countROM)
				pagingdevice->iROMStats.iMaxReqsInPending=countROM;
			pagingdevice->iCodeStats.iTotalSynchServicedFromMainQ+=countCode;
			if(pagingdevice->iCodeStats.iMaxReqsInPending<countCode)
				pagingdevice->iCodeStats.iMaxReqsInPending=countCode;
			NKern::FMSignal(&pagingdevice->iInstrumentationLock);
#endif
			}	// if (pM)
		}	// 	if(iPagingMedia)
#endif
	if (iRunningDeferred)
	    {
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT4, this );
		return;
	    }
	TMessageBase* pL = iDeferred.Last();
	if (!pL)
	    {
		OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT5, this );
		return;	// no deferred requests
	    }
	iRunningDeferred=1;
	TMessageBase* pM=NULL;

	while( pM != pL && (pM=iDeferred.Poll()) != NULL)	// stop after processing last one (requests may be re-deferred)
		DoRequest(*(TLocDrvRequest*)pM);
	iRunningDeferred=0;
	
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_RUNDEFERRED_EXIT6, this );
	}

void DPrimaryMediaBase::SetClosed(TInt anError)
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_SETCLOSED_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::SetClosed error %d",iMediaId,anError));
	OstTraceExt2( TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_SETCLOSED, "iMediaId=%d; anError=%d", iMediaId, anError );
	CHECK_RET(anError);

	// cancel DMediaDriver::OpenMediaDriverComplete() / DMediaDriver::PartitionInfoComplete() DFC
	iAsyncDfc.Cancel();

	iDeferred.CompleteAll(anError);

#ifdef __DEMAND_PAGING__
	if(iPagingMedia)
		iBody->iPagingDevice->iDeferredQ.CompleteAll(anError);
#endif

	CompleteCurrent(anError);

	

	if (iState==EOpening)
		iPhysDevArray.Close();

	iState = EClosed;

	iWaitMedChg.CompleteAll(KErrNone);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_SETCLOSED_EXIT, this );
	}

void DPrimaryMediaBase::NotifyClients(TNotifyType aNotifyType, TLocDrv* aLocDrv)

//
// Notify all clients of a media change or media present event
//
	{
	OstTraceFunctionEntryExt( DPRIMARYMEDIABASE_NOTIFYCLIENTS_ENTRY, this );
	
	SDblQueLink* pL=iConnectionQ.iA.iNext;
	while (pL!=&iConnectionQ.iA)
		{
		// Get pointer to TCallBackLink
		TCallBackLink* pCallBackLink = _LOFF(pL,TCallBackLink,iLink);

		// The link is embedded in either a TLocDrv or a  DLocalDrive object;
		// find out which one it is and then get TLocDrv pointer from that
		__ASSERT_DEBUG(pCallBackLink->iObjectType == TCallBackLink::EDLocalDriveObject || pCallBackLink->iObjectType == TCallBackLink::ETLocDrvObject, LOCM_FAULT());
		TLocDrv* locDrv;
		if (pCallBackLink->iObjectType == TCallBackLink::EDLocalDriveObject)
			locDrv = ((DLocalDrive*) _LOFF(pCallBackLink,DLocalDrive, iMediaChangeObserver))->iDrive;
		else
			locDrv = ((TLocDrv*) _LOFF(pCallBackLink,TLocDrv, iMediaChangeObserver))->iNextDrive;

		// Issue the notification if the caller wants to notify all drives (aLocDrv == NULL) or 
		// the specified drive matches this one
		if (aLocDrv == NULL || aLocDrv == locDrv)
			pCallBackLink->CallBack(aNotifyType);

		pL=pL->iNext;
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYCLIENTS_EXIT, this );
	}

EXPORT_C void DPrimaryMediaBase::NotifyMediaChange()
/**
Closes all media drivers on this device and notifies all connections that media change has occurred 
and completes any outstanding requests with KErrNotReady. 
This also completes any force media change requests with KErrNone.
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyMediaChange state %d",iMediaId,iState));

	OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE, "iMediaId=%d; iState=%d", iMediaId, iState );
	
	// This should only be called in the context of the media thread
	__ASSERT_ALWAYS(NKern::CurrentThread() == iDfcQ->iThread, LOCM_FAULT());

	MediaChange();

	// notify all connections that media change has occurred
	NotifyClients(EMediaChange);

	// complete any force media change requests
	iWaitMedChg.CompleteAll(KErrNone);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYMEDIACHANGE_EXIT, this );
	}


EXPORT_C void DPrimaryMediaBase::NotifyPowerDown()
/**
Called on machine power-down. Notifies all media drivers on this device. 
If device is not ready then it completes current requests but leaves other outstanding requests
If ready, media driver should complete current request.

*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYPOWERDOWN_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyPowerDown state %d",iMediaId,iState));
	
	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPOWERDOWN, "iMediaId=%d; iState=%d", iMediaId, iState );
	
	TInt id;
	TBool allPersistent = ETrue;
	TBool allOpen = ETrue;

	 // notify all media drivers on this device
	for (id=iMediaId; id<=iLastMediaId; id++)
		{
		DMedia* pM = TheMedia[id];
		DMediaDriver* pD = pM->iDriver; 
		
		if ((pD) && (iState==EReady || iState==EReadPartitionInfo || iState==EOpening || iState==EPoweringUp2 || iState==ERecovering))
			pD->NotifyPowerDown();

		if (pD == NULL || pD->iPhysicalDevice == NULL)
			allOpen = EFalse;
		else if (pD->iPhysicalDevice->Info(DPhysicalDevice::EMediaDriverPersistent, NULL) != KErrNone)
			{
			// We must NOT destroy the media driver if this media is responsible for data paging as 
			// re-opening the media driver would involve memory allocation which might cause a deadlock
#ifdef __DEMAND_PAGING__
			__ASSERT_ALWAYS(!DataPagingDfcQ(this), LOCM_FAULT());
#endif
			allPersistent = EFalse;
			}
		}

	__KTRACE_OPT(KLOCDRV,Kern::Printf("allPersistent(%d)::allOpen %d",allPersistent, allOpen));
	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPOWERDOWN2, "allPersistent=%d; allOpen=%d", allPersistent, allOpen );

	if (allPersistent && allOpen && iState == EReady)
		{
		//
		// The EPoweredDown state indicates that the media is powered down, but the media driver still exists.
		//
		//  - This allows the media driver to still be accessed (ie - to determine driver capabilities) without
		//    the need to power up the device, which can be a lengthy operation.
		//
		//  - NOTE : This will need re-visiting if we ever re-enable standby mode on a platform that is not capable
		//           of detecting door interrupts while in standby.  In such a scenario, problems could occur as 
		//			the device capabilities may change without the local media subsystem recognising.
		//
		iState=EPoweredDown;
		}
	else
		{
		CloseMediaDrivers();
		SetClosed(KErrNotReady);
		}
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYPOWERDOWN_EXIT, this );
	}


EXPORT_C void DPrimaryMediaBase::NotifyPsuFault(TInt anError)
/**
Closes all media drivers on this device and completes any outstanding requests with error code.
@param anError Error code to be passed on while closing media drivers and completing outstanding requests.
*/

	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYPSUFAULT_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyPsuFault state %d, err %d",iMediaId,iState,anError));
	OstTraceExt3( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYPSUFAULT, "iMediaId=%d; iState=%d; anError=%d", iMediaId, iState, anError );
	
	if (iState>=EOpening)
		{
		CloseMediaDrivers();
		}

	// complete any outstanding requests with error
	SetClosed(anError);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYPSUFAULT_EXIT, this );
	}

EXPORT_C void DPrimaryMediaBase::NotifyEmergencyPowerDown()
/**
Called on emergency power down. Notifies all media drivers on this device. 
If it is not in a ready state then it completes the current request but leaves other outstanding requests.
If it is ready then the media driver should complete the current request. 
It closes all media drivers and notifies all clients of a power down event.
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyEmergencyPowerDown state %d",iMediaId,iState));
	OstTraceExt2( TRACE_INTERNALS, DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN, "iMediaId=%d; iState=%d", iMediaId, iState );
	
	TBool recover=EFalse;
	if (iState==EReady && iCritical!=0)
		{
		// check if emergency power recovery supported
		;
		}
	if (recover)
		{
		}

	// else just return KErrAbort
	// notify all media drivers on this device
	if (iState==EReady || iState==EOpening || iState==EPoweringUp2 || iState==ERecovering)
		{
		TInt id;
		for (id=iMediaId; id<=iLastMediaId; id++)
			{
			DMedia* pM=TheMedia[id];
			DMediaDriver* pD=pM->iDriver;
			if (pD)
				pD->NotifyEmergencyPowerDown();
			}
		}

	if (iState!=EReady)
		{
		// complete current request but leave other outstanding requests
		// if ready, media driver should complete current request
		CompleteCurrent(KErrNotReady);
		}
	CloseMediaDrivers();
	SetClosed(KErrNotReady);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYEMERGENCYPOWERDOWN_EXIT, this );
	}


/**
Called by NotifyMediaPresent() and NotifyMediaChange() to ensure the media is in the correct state
*/
void DPrimaryMediaBase::MediaChange()
	{
	// Media has been inserted, so we need to cancel any outstanding requests and 
	// ensure that the partition info is read again
	TInt state = iState;

	__ASSERT_DEBUG(iBody, LOCM_FAULT());

#ifdef __DEMAND_PAGING__
	iBody->iMediaChanges++;

	// As data paging media never close, need to ensure the media driver cancels
	// any requests it owns as the stack may be powered down by DPBusPrimaryMedia::ForceMediaChange().
	// DMediaDriver::NotifyPowerDown() should do this
	if (DataPagingMedia(this))
		NotifyPowerDown();
#endif

	// complete any outstanding requests with KErrNotReady
	// and any force media change requests with KErrNone
	SetClosed(KErrNotReady);

	// close all media drivers on this device
	if (state>=EOpening)
		{
		CloseMediaDrivers();
		}
	}

EXPORT_C void DPrimaryMediaBase::NotifyMediaPresent()
/**
Notifies clients of a media change by calling NotifyClients ( ) function to indicate that media is present.
*/
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_NOTIFYMEDIAPRESENT_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DPrimaryMediaBase(%d)::NotifyMediaPresent state %d",iMediaId,iState));

	// This should only be called in the context of the media thread
	__ASSERT_ALWAYS(NKern::CurrentThread() == iDfcQ->iThread, LOCM_FAULT());

	MediaChange();

	NotifyClients(EMediaPresent);
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_NOTIFYMEDIAPRESENT_EXIT, this );
	}

EXPORT_C TInt DPrimaryMediaBase::DoInCritical()
/**
Flags the media driver as entering a critical part of its processing.

In this context, critical means that the driver must be allowed to complete
its current activity.
For example, a request to power down the device must be deferred until
the driver exits the critical part.

@return KErrNone, if the driver has been successfully flagged as being in
        a critical part; otherwise, one of the other system-wide error codes.
        The default implementation just returns KErrNone and can be overridden in the derived class
@see DPrimaryMediaBase::DoEndInCritical()
*/

	{
	return KErrNone;
	}

EXPORT_C void DPrimaryMediaBase::DoEndInCritical()
/**
Flags the media driver as leaving a critical part of its processing.

Default implementation does nothing
@see DPrimaryMediaBase::DoEndInCritical()
*/
	{
	}

TInt DPrimaryMediaBase::InCritical()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_INCRITICAL_ENTRY, this );
	if (iCritical==0)
		{
		TInt r=DoInCritical();
		if (r!=KErrNone)
		    {
			OstTraceFunctionExitExt( DPRIMARYMEDIABASE_INCRITICAL_EXIT1, this, r );
			return r;
		    }
		}
	++iCritical;
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_INCRITICAL_EXIT2, this, KErrNone );
	return KErrNone;
	}

void DPrimaryMediaBase::EndInCritical()
	{
	OstTraceFunctionEntry1( DPRIMARYMEDIABASE_ENDINCRITICAL_ENTRY, this );
	if (--iCritical==0)
		DoEndInCritical();
	OstTraceFunctionExit1( DPRIMARYMEDIABASE_ENDINCRITICAL_EXIT, this );
	}

EXPORT_C void DPrimaryMediaBase::DeltaCurrentConsumption(TInt /*aCurrent*/)
/**
Sets the incremental value of current consumption to aCurrent.
The default implementation does nothing .

@param aCurrent Delta Current in Milliamps
*/
	{
	// default implementation
	}

TInt DPrimaryMediaBase::OpenMediaDriver()
//
// Synchronous open for devices with no DFC queue (e.g. IRAM)
//
	{
    OstTraceFunctionEntry1( DPRIMARYMEDIABASE_OPENMEDIADRIVER_ENTRY, this );
    
	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DPrimaryMediaBase:OpenMediaDriver-%d",iMediaId));
	OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENMEDIADRIVER1, "iMediaId=%d", iMediaId);
	
	TVersion ver(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);

	// Get a list of all currently loaded media drivers
	// Most media drivers do not make use of the pointer iMountInfo.iInfo when 
	// their Validate() procedures are called from RPhysicalDeviceArray::GetDriverList(). 
	// However, a group of media drivers sharing the same id (passed in iDevice) may use 
	// the additional information pointed to by iMountInfo.iInfo to distinguish 
	// group members. This information is passed when the media driver is registered 
	// using LocDrv::RegisterMediaDevice().
	TInt r=iPhysDevArray.GetDriverList(KLitMediaDriverName,iDevice,iMountInfo.iInfo,ver);
	if (r!=KErrNone)
	    {
		OstTraceFunctionExitExt( DPRIMARYMEDIABASE_OPENMEDIADRIVER_EXIT1, this, r );
		return r;
	    }
	// Go through them starting with highest priority
	TInt totalPartitions=0;
	TInt c=iPhysDevArray.Count();	// can't be zero
	TInt i=c-1;
	r=KErrNotSupported;
	for (iNextMediaId=iMediaId; i>=0 && iNextMediaId<=iLastMediaId && r!=KErrNotReady; i--)
		{
		DPhysicalDevice* pD=iPhysDevArray[i].iPhysicalDevice;
		DMediaDriver *pM=NULL;

		// try to open media driver
		TInt s=pD->Create( (DBase*&)pM, iMediaId, NULL, ver); 

		__KTRACE_OPT(KLOCDRV,Kern::Printf("Media:Open-Opening %o(PRI:%d)-%d",pD,iPhysDevArray[i].iPriority,s));
		OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DPRIMARYMEDIABASE_OPENMEDIADRIVER2, "Media:Open-Opening 0x%x iPriority=%d; retval=%d", (TUint) pD, (TUint) iPhysDevArray[i].iPriority, (TUint) s);
		if (s!=KErrNone && pM)
			{
			pM->Close();
			pM=NULL;
			}
		if (s==KErrNotReady)
			{
			r=KErrNotReady; // If it isn't ready - nothing will open.
			break;
			}
		if (s==KErrNoMemory)
			{
			r=KErrNoMemory; // If we are out of memory, give up now
			break;
			}
		if (s==KErrNone)
			{
			// Found a media driver for this device - check for valid partitions.
			DMedia* media=TheMedia[iNextMediaId];
			s=pM->PartitionInfo(media->iPartitionInfo);
			if (s==KErrNone)
				{
				r=KErrNone;
				media->iDriver=pM;
				pM->iPhysicalDevice=pD;
				iPhysDevArray[i].iPhysicalDevice=NULL;	// so it won't be closed when we tidy up
				totalPartitions+=media->PartitionCount();
				}
			else
				pM->Close();
			}
		}

	// we are now finished with media driver list
	iPhysDevArray.Close();

	// if driver opened OK, work out mapping of drives to partitions/media
	if (r==KErrNone)
		{
		TInt id=iMediaId;	// start with primary media
		TInt partitionsOnThisMedia=PartitionCount();
		TInt partition=0;
		
		TDriveIterator driveIter;
		for (TLocDrv* pD = driveIter.NextDrive(); pD != NULL; pD = driveIter.NextDrive())
			{
			if (pD && pD->iPrimaryMedia==this)
				{
				if (totalPartitions==0)
					{
					pD->iMedia=NULL;
					continue;
					}
				if (partition==partitionsOnThisMedia)
					{
					id++;
					partition=0;
					partitionsOnThisMedia=TheMedia[id]->PartitionCount();
					}
				pD->iMedia=TheMedia[id];
				pD->iPartitionNumber=partition;
				memcpy(pD, pD->iMedia->iPartitionInfo.iEntry+partition, sizeof(TPartitionEntry));
				partition++;
				totalPartitions--;
				}
			}
		}

	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DPrimaryMediaBase:OpenMediaDriver-%d",r));
	OstTraceFunctionExitExt( DPRIMARYMEDIABASE_OPENMEDIADRIVER_EXIT2, this, r );
	return r;
	}

#ifdef __DEMAND_PAGING__
// RequestCountInc()
// 
// Counts the number of outstanding requests
// For data-paging media, calls DPagingDevice::NotifyBusy() when count goes positive
//
void DPrimaryMediaBase::RequestCountInc()
	{
	__ASSERT_DEBUG(iBody, LOCM_FAULT());
	if (iBody->iPagingDevice)
		{
		NFastMutex* lock = iBody->iPagingDevice->NotificationLock();
		NKern::FMWait(lock);
		TInt oldVal = iBody->iRequestCount++;
		//Kern::Printf("RCINC: this %x cnt %d, old %d", this, iBody->iRequestCount, oldVal);
		OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_REQUESTCOUNTINC, "new count=%d; old count=%d", iBody->iRequestCount, oldVal );
		if (oldVal == 0)
			{
			//Kern::Printf("RCINC: NotifyBusy()");
			iBody->iPagingDevice->NotifyBusy();
			}
		NKern::FMSignal(lock);
		}
	}

// RequestCountDec()
// 
// Counts the number of outstanding requests
// For data-paging media, calls DPagingDevice::NotifyIdle() when count reaches zero
//
void DPrimaryMediaBase::RequestCountDec()
	{
	__ASSERT_DEBUG(iBody, LOCM_FAULT());
	if (iBody->iPagingDevice)
		{
		NFastMutex* lock = iBody->iPagingDevice->NotificationLock();
		NKern::FMWait(lock);
		TInt oldVal = iBody->iRequestCount--;
		//Kern::Printf("RCDEC: this %x cnt %d, old %d", this, iBody->iRequestCount, oldVal);
		OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DPRIMARYMEDIABASE_REQUESTCOUNTDEC, "new count=%d; old count=%d", iBody->iRequestCount, oldVal );
		if (oldVal == 1)
			{
			//Kern::Printf("RCDEC: NotifyIdle()");
			iBody->iPagingDevice->NotifyIdle();
			}		
		NKern::FMSignal(lock);
		__ASSERT_DEBUG(iBody->iRequestCount >= 0, LOCM_FAULT());
		}
	}
#endif	// __DEMAND_PAGING__

TPartitionInfo::TPartitionInfo()
//
// Constructor
//
	{
	memclr(this, sizeof(TPartitionInfo));
	}

#ifdef __DEMAND_PAGING__

void pageInDfc(TAny* aPtr)
	{
	OstTraceFunctionEntry0( _PAGEINDFC_ENTRY );
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("pageInDfc"));
	DPrimaryMediaBase* primaryMedia=(DPrimaryMediaBase*)aPtr;
	__ASSERT_ALWAYS(primaryMedia && primaryMedia->iPagingMedia && primaryMedia->iBody->iPagingDevice,LOCM_FAULT());
	DMediaPagingDevice* pagingdevice=primaryMedia->iBody->iPagingDevice;

	TLocDrvRequest* m = (TLocDrvRequest*) pagingdevice->iMainQ.iMessage;
	pagingdevice->iMainQ.iMessage = NULL;

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	if (!m)
		__e32_atomic_add_ord8(&pagingdevice->iROMStats.iTotalRunDry, 1);
#endif

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	TInt countROM=0;
	TInt countCode=0;
#endif

	for ( ; m != NULL; m = (TLocDrvRequest*) pagingdevice->iMainQ.Poll())
		{
		__ASSERT_ALWAYS(DMediaPagingDevice::PagingRequest(*m), LOCM_FAULT());

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
		(m->iValue == DMediaPagingDevice::ERomPageInRequest)?(countROM++):(countCode++);
#endif
		__KTRACE_OPT(KLOCDPAGING, Kern::Printf("pageInDfc: process request 0x%08x, last in queue 0x%08x",m, pagingdevice->iMainQ.Last()) );
		OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, PAGEINDFC2, "process request=0x%08x; last in queue=0x%08x",(TUint) m, (TUint) pagingdevice->iMainQ.Last());

		primaryMedia->HandleMsg(*m);
		}

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	NKern::FMWait(&pagingdevice->iInstrumentationLock);
	if (pagingdevice->iROMStats.iMaxReqsInPending<countROM)
		pagingdevice->iROMStats.iMaxReqsInPending=countROM;
	if (pagingdevice->iCodeStats.iMaxReqsInPending<countCode)
		pagingdevice->iCodeStats.iMaxReqsInPending=countCode;
	NKern::FMSignal(&pagingdevice->iInstrumentationLock);
#endif

	pagingdevice->iMainQ.Receive();	// allow reception of more messages
	OstTraceFunctionExit0( _PAGEINDFC_EXIT );
	}

DMediaPagingDevice::DMediaPagingDevice(DPrimaryMediaBase* aPtr)
	:	iMainQ(pageInDfc, aPtr, NULL, KMaxDfcPriority),
		iDeferredQ(NULL, NULL, NULL, 0),			// callback never used
		iEmptyingQ(NULL),
		iInstrumentationLock()
#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
		,iServicingROM(NULL), iServicingCode(NULL)
#endif
	{
	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_CONSTRUCTOR_ENTRY, this );
	iPrimaryMedia = aPtr;
	if (iPrimaryMedia->iDfcQ)	// media driver has its own thread
		{
		iMainQ.SetDfcQ(iPrimaryMedia->iDfcQ);
		}
#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	memclr((TAny*)&iROMStats,sizeof(SMediaROMPagingConcurrencyInfo)+sizeof(SMediaCodePagingConcurrencyInfo));
#endif
#ifdef __DEMAND_PAGING_BENCHMARKS__
	iROMBenchmarkData.iCount=iROMBenchmarkData.iTotalTime=iROMBenchmarkData.iMaxTime=0;
	iROMBenchmarkData.iMinTime = KMaxTInt;
	iCodeBenchmarkData.iCount=iCodeBenchmarkData.iTotalTime=iCodeBenchmarkData.iMaxTime=0;
	iCodeBenchmarkData.iMinTime = KMaxTInt;
	iDataInBenchmarkData.iCount=iDataInBenchmarkData.iTotalTime=iDataInBenchmarkData.iMaxTime=0;
	iDataInBenchmarkData.iMinTime = KMaxTInt;
	iDataOutBenchmarkData.iCount=iDataOutBenchmarkData.iTotalTime=iDataOutBenchmarkData.iMaxTime=0;
	iDataOutBenchmarkData.iMinTime = KMaxTInt;
#endif

	iMainQ.Receive();
	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_CONSTRUCTOR_EXIT, this );
	}

DMediaPagingDevice::~DMediaPagingDevice()
	{
OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_DESTRUCTOR_ENTRY, this );

	if (iMountInfoDataLock)
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDataLock);
	
	if (iMountInfoDescHdrLock)
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDescHdrLock);
	
	if (iMountInfoDescLenLock)
		ThePinObjectAllocator->ReleasePinObject((DPinObjectAllocator::SVirtualPinContainer*) iMountInfoDescLenLock);
	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_DMEDIAPAGINGDEVICE_DESTRUCTOR_EXIT, this );
	}


void DMediaPagingDevice::SendToMainQueueDfcAndBlock(TThreadMessage* aMsg)
	{
	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_SENDTOMAINQUEUEDFCANDBLOCK_ENTRY, this );
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("Send request 0x%08x to main queue",aMsg));
	__ASSERT_ALWAYS(aMsg->iState==TMessageBase::EFree,LOCM_FAULT());	// check that message was previously completed or never queued

	// if drive supports DMA, turn on Physical memory flag & sync memory
	TLocDrvRequest& m=*(TLocDrvRequest*)(aMsg);
	
	TLinAddr addr = (TLinAddr) m.RemoteDes();
	TInt len = I64LOW(m.Length());

	TBool needSyncAfterRead = EFalse;
    if (m.Drive()->iDmaHelper)
        {        
        m.Flags() |= TLocDrvRequest::EPhysAddr;
        // don't cache sync for zero mapping...
        if (!(m.Flags() & TLocDrvRequest::EPhysAddrOnly))
            {
            if (m.Id() == DLocalDrive::EWrite)
                {
                Cache::SyncMemoryBeforeDmaWrite(addr, len);
                }
            else
                {
                Cache::SyncMemoryBeforeDmaRead(addr, len);
                needSyncAfterRead = ETrue;
                }
            }
	    }

	// Count the number of outstanding requests if this is the data-paging media, so that
	// we can call DPagingDevice::NotifyBusy() / DPagingDevice::NotifyIdle()
	if ((m.Flags() & TLocDrvRequest::EBackgroundPaging) == 0)
		iPrimaryMedia->RequestCountInc();
	
	aMsg->SendReceive(&iMainQ);

#ifdef __DEMAND_PAGING__
	if ((m.Flags() & TLocDrvRequest::EBackgroundPaging) == 0)
		iPrimaryMedia->RequestCountDec();
#endif

	if (needSyncAfterRead)
		{
		Cache::SyncMemoryAfterDmaRead(addr, len);
		}

	
	// come back here when request is completed
	__ASSERT_DEBUG(aMsg->iState==TMessageBase::EFree,LOCM_FAULT());		// check message has been completed
	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_SENDTOMAINQUEUEDFCANDBLOCK_EXIT, this );
	}

void DMediaPagingDevice::SendToDeferredQ(TThreadMessage* aMsg)
	{
	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_SENDTODEFERREDQ_ENTRY, this );
	// This queue is only accessed from MD thread
	__ASSERT_ALWAYS(aMsg->iState==TMessageBase::EAccepted,LOCM_FAULT());	// check that message was previously dequeued
#ifdef BTRACE_PAGING_MEDIA
	if(iEmptyingQ&DMediaPagingDevice::EDeferredQ)		// already deferring
		BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInReDeferred,aMsg,aMsg->iValue);
	else
		BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInDeferred,aMsg,aMsg->iValue);
#endif

	aMsg->Forward(&iDeferredQ, EFalse);
	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_SENDTODEFERREDQ_EXIT, this );
	}


void DMediaPagingDevice::CompleteRequest(TThreadMessage* aMsg, TInt aResult)
	{
	OstTraceFunctionEntryExt( DMEDIAPAGINGDEVICE_COMPLETEREQUEST_ENTRY, this );
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::CompleteRequest, request 0x%08x result %d", aMsg, aResult));
	__ASSERT_DEBUG(aMsg->iState==TMessageBase::EAccepted,LOCM_FAULT());

#ifdef BTRACE_PAGING_MEDIA
	BTraceContext12(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInPagedIn,aMsg,aResult,aMsg->iValue);
#endif

	iPrimaryMedia->CompleteRequest(*((TLocDrvRequest*) aMsg), aResult);
	OstTraceFunctionExit1( DMEDIAPAGINGDEVICE_COMPLETEREQUEST_EXIT, this );
	}

TInt DMediaPagingDevice::Read(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TInt aDrvNumber)
    {
    return BaseRead(aReq,(TUint32)aBuffer,aOffset,aSize,aDrvNumber,EFalse);
    }

TInt DMediaPagingDevice::ReadPhysical(TThreadMessage* aReq, TPhysAddr* aPageArray, TUint aPageCount, TUint aOffset, TInt aDrvNumber)
    {    
    TUint adjSize = (aPageCount << iPrimaryMedia->iBody->iPageSizeLog2) >> iReadUnitShift; // translate to Read Units
    return BaseRead(aReq,(TUint32)aPageArray,aOffset,adjSize,aDrvNumber,ETrue);
    }

TInt DMediaPagingDevice::BaseRead(TThreadMessage* aReq,TUint32 aBuffer,TUint aOffset,TUint aSize,TInt aDrvNumber, TBool aPhysAddr)
	{
	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_READ_ENTRY, this );
	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
	__ASSERT_CRITICAL

#ifdef __DEMAND_PAGING_BENCHMARKS__
	TUint32 bmStart = NKern::FastCounter();
#endif

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	TUint8* servicingCount;
	NKern::FMWait(&iInstrumentationLock);
	if(aDrvNumber == EDriveRomPaging)	// ROM paging
		{
		servicingCount = &iServicingROM;
		if(iServicingROM)
			iROMStats.iTotalConcurrentReqs++;
		if(!(++iServicingROM))
			{
			iServicingROM=1;					// overflow...
			iROMStats.iTotalConcurrentReqs=0;	// ...reset this
			}
		TBool empty = iMainQ.iReady && iDeferredQ.iQ.IsEmpty();
		if(!empty)
			iROMStats.iTotalReqIssuedNonEmptyQ++;
		}
	else if (aDrvNumber == EDriveDataPaging)	// Data paging
		{
		servicingCount = &iServicingDataIn;
		if(iServicingDataIn)
			iDataStats.iTotalConcurrentReqs++;
		if(!(++iServicingDataIn))
			{
			iServicingDataIn=1;					// overflow...
			iDataStats.iTotalConcurrentReqs=0;	// ...reset this
			}
		TBool empty = iMainQ.iReady && iDeferredQ.iQ.IsEmpty();
		if(!empty)
			iDataStats.iTotalReqIssuedNonEmptyQ++;
		}
	else
		{
		servicingCount = &iServicingCode;
		if(iServicingCode)
			iCodeStats.iTotalConcurrentReqs++;
		if(!(++iServicingCode))
			{
			iServicingCode=1;					// overflow...
			iCodeStats.iTotalConcurrentReqs=0;	// ...reset this
			}
		TBool empty = iMainQ.iReady && iDeferredQ.iQ.IsEmpty();
		if(!empty)
			iCodeStats.iTotalReqIssuedNonEmptyQ++;
		}
	NKern::FMSignal(&iInstrumentationLock);
#endif

	TUint offset=aOffset<<iReadUnitShift;
	TUint size=aSize<<iReadUnitShift;

#ifdef BTRACE_PAGING_MEDIA
	TInt buf[3];
	buf[0]=size;		// page in request length
	buf[1]=aDrvNumber;	// local drive number (-1 if ROM)
	buf[2]=(TInt)aReq;	// address of request object
	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageInBegin,aBuffer,offset,buf,sizeof(buf));
#endif

	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Read, Req(0x%08x), Buff(0x%x),Offset(%d),Size(%d),DrvNo(%d)",aReq,aBuffer,offset,size,aDrvNumber));
	OstTraceDefExt5(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_READ1, "req=0x%08x; aBuffer=0x%x; offset=%d; size=%d; aDrvNumber=%d", (TUint) aReq, (TInt) aBuffer, (TInt) offset, (TUint) size, (TUint) aDrvNumber);
	
	// no DFCQ, media driver executes in the context of calling thread
	if (!iPrimaryMedia->iDfcQ)
		{
		LOCM_FAULT();		// don't allow paging
		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_READ_EXIT, this, KErrNone );
		return KErrNone;	// keep compiler happy
		}


	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);
	

#ifdef __DEMAND_PAGING_BENCHMARKS__
	SPagingBenchmarkInfo* info = NULL;
#endif


	// Read from the media and allow for retries in the unlikely event of an error.
	const TInt KPageInRetries = 5;
	TInt retVal = KErrGeneral;
	for (TInt i=0; retVal != KErrNone && i < KPageInRetries; i++)
		{
		m.Flags() = TLocDrvRequest::EKernelBuffer | TLocDrvRequest::EPaging;
		TLocDrv* pL=NULL;
		if(aDrvNumber == EDriveRomPaging)					// ROM paging
			{
			m.Id() = DMediaPagingDevice::ERomPageInRequest;
			if (iRomPagingDriveNumber == KErrNotFound)
			    {
			    // ROM partition has not been reported by the media driver
			    // it is assumed that the media driver will adjust the request accordingly
			    m.Flags() |= TLocDrvRequest::EAdjusted;
				// Use a media drive number so the request reaches the correct media...
				m.Drive() = TheDrives[iFirstLocalDriveNumber];
			    }
			else
			    {
			    //ROM partition has been reported
			    //Set drive for use with CheckAndAdjustForPartition
                m.Drive() = TheDrives[iRomPagingDriveNumber];
			    }
#ifdef __DEMAND_PAGING_BENCHMARKS__
			__e32_atomic_add_ord32(&iMediaPagingInfo.iRomPageInCount, (TUint) 1);
			info = &iROMBenchmarkData;
#endif
			}
		else if(aDrvNumber == EDriveDataPaging)				// Data paging
			{
			m.Id() = DLocalDrive::ERead;
			m.Flags() |= TLocDrvRequest::EDataPaging;
			m.Drive() = TheDrives[iDataPagingDriveNumber];
#ifdef __DEMAND_PAGING_BENCHMARKS__
			__e32_atomic_add_ord32(&iMediaPagingInfo.iDataPageInCount, (TUint) 1);
			info = &iDataInBenchmarkData;
#endif
			}
		else if ((aDrvNumber >=0) && (aDrvNumber<KMaxLocalDrives))	// Code paging
			{
			m.Id() = DMediaPagingDevice::ECodePageInRequest;
			m.Flags() |= TLocDrvRequest::ECodePaging;
			pL=TheDrives[aDrvNumber];
			__ASSERT_DEBUG(pL && TDriveIterator::GetDrive(aDrvNumber, iPrimaryMedia) ,LOCM_FAULT());	// valid drive number?
			m.Drive()=pL;
#ifdef __DEMAND_PAGING_BENCHMARKS__
			__e32_atomic_add_ord32(&iMediaPagingInfo.iCodePageInCount, (TUint) 1);
			info = &iCodeBenchmarkData;
#endif
			}
		else
			LOCM_FAULT(); // invalid drive number

		m.RemoteThread()=NULL;
		m.Pos()=offset;
		m.Length()=Int64(size);
		m.RemoteDes()=(TAny*)aBuffer;
		m.RemoteDesOffset()=0;		// pre-aligned
		m.DriverFlags() = 0;
		if (aPhysAddr)
		    m.Flags() |= TLocDrvRequest::EPhysAddrOnly;

		__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
		OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_READ2, "reqId=%d; remote Des=0x%x", (TInt) m.Id(), (TUint) m.RemoteDes());
		OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_READ3, "length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
		
		__ASSERT_DEBUG(iPrimaryMedia->iBody, LOCM_FAULT());
		TInt mediaChanges = iPrimaryMedia->iBody->iMediaChanges;

		SendToMainQueueDfcAndBlock(&m);		// queues request, sets and opens client thread, queues dfc and blocks thread until request is completed
		retVal = m.iValue;

#ifdef __DEBUG_DEMAND_PAGING__
		if (retVal != KErrNone)
		    {
			Kern::Printf("Pagin Failure %d, retry %d", retVal, i);
		    }
#endif

		// reset retry count if there's ben a media change
		if (retVal != KErrNone && mediaChanges != iPrimaryMedia->iBody->iMediaChanges)
			i = 0;
		}	// for ()

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	NKern::FMWait(&iInstrumentationLock);
	if (*servicingCount)
		(*servicingCount)--;
	NKern::FMSignal(&iInstrumentationLock);
#endif

#ifdef __DEMAND_PAGING_BENCHMARKS__
	TUint32 bmEnd = NKern::FastCounter();
	++info->iCount;
#if !defined(HIGHIGH_RES_TIMER) || defined(HIGH_RES_TIMER_COUNTS_UP)
	TInt64 elapsed=bmEnd-bmStart;
#else
	TInt64 elapsed=bmStart-bmEnd;
#endif
	info->iTotalTime += elapsed;
	if (elapsed > info->iMaxTime)
		info->iMaxTime = elapsed;
	if (elapsed < info->iMinTime)
		info->iMinTime = elapsed;
#endif // __DEMAND_PAGING_BENCHMARKS__
	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_READ_EXIT2, this, retVal );
	return retVal;
	}

TInt DMediaPagingDevice::Write(TThreadMessage* aReq,TLinAddr aBuffer,TUint aOffset,TUint aSize,TBool aBackground)
    {
    return BaseWrite(aReq,(TUint32)aBuffer,aOffset,aSize,aBackground,EFalse);
    }

TInt DMediaPagingDevice::WritePhysical(TThreadMessage* aReq, TPhysAddr* aPageArray, TUint aPageCount, TUint aOffset, TBool aBackground)
	{
    TUint adjSize = (aPageCount << iPrimaryMedia->iBody->iPageSizeLog2) >> iReadUnitShift; // translate to Read Units
    return BaseWrite(aReq,(TUint32)aPageArray,aOffset,adjSize,aBackground,ETrue);
	}

TInt DMediaPagingDevice::BaseWrite(TThreadMessage* aReq,TUint32 aBuffer,TUint aOffset,TUint aSize,TBool aBackground, TBool aPhysAddr)
    {
	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_WRITE_ENTRY, this );
	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
	__ASSERT_CRITICAL

#ifdef __DEMAND_PAGING_BENCHMARKS__
	TUint32 bmStart = NKern::FastCounter();
#endif

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	NKern::FMWait(&iInstrumentationLock);
	if(iServicingDataOut)
		iDataStats.iTotalConcurrentReqs++;
	if(!(++iServicingDataOut))
		{
		iServicingDataOut=1;				// overflow...
		iDataStats.iTotalConcurrentReqs=0;	// ...reset this
		}
	TBool empty = iMainQ.iReady && iDeferredQ.iQ.IsEmpty();
	if(!empty)
		iDataStats.iTotalReqIssuedNonEmptyQ++;
	NKern::FMSignal(&iInstrumentationLock);
#endif

	TUint offset=aOffset<<iReadUnitShift;
	TUint size=aSize<<iReadUnitShift;

#ifdef BTRACE_PAGING_MEDIA
	TInt buf[2];
	buf[0] = size;				// page out request length
	buf[1] = (TInt)aReq;		// address of request object
	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedPageOutBegin,aBuffer,offset,buf,sizeof(buf));
#endif

	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Write, Req(0x%08x), Buff(0x%x),Offset(%d),Size(%d)",aReq,aBuffer,offset,size));
	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_WRITE1, "req=0x%08x; aBuffer=0x%x; offset=%d; size=%d", (TUint) aReq, (TUint) aBuffer, offset, size);
	
	// no DFCQ, media driver executes in the context of calling thread
	if (!iPrimaryMedia->iDfcQ)
		{
		LOCM_FAULT();		// don't allow paging
		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_WRITE_EXIT, this, KErrNone );
		return KErrNone;	// keep compiler happy
		}


	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);
	
#ifdef __DEMAND_PAGING_BENCHMARKS__
	__e32_atomic_add_ord32(&iMediaPagingInfo.iDataPageOutCount, (TUint) 1);
	if (aBackground)
		__e32_atomic_add_ord32(&iMediaPagingInfo.iDataPageOutBackgroundCount, (TUint) 1);
#endif

	// Write to the media and allow for retries in the unlikely event of an error.
	const TInt KPageOutRetries = 5;
	TInt retVal = KErrGeneral;
	for (TInt i=0; retVal != KErrNone && i < KPageOutRetries; i++)
		{
		m.Flags() = TLocDrvRequest::EKernelBuffer |
					TLocDrvRequest::EPaging | 
                    TLocDrvRequest::EDataPaging | 
                    (aBackground ? TLocDrvRequest::EBackgroundPaging : 0) |
                    (aPhysAddr ? TLocDrvRequest::EPhysAddrOnly : 0);

		m.Id() = DLocalDrive::EWrite;
		m.Drive() = TheDrives[iDataPagingDriveNumber];

		m.RemoteThread()=NULL;
		m.Pos()=offset;
		m.Length()=Int64(size);
		m.RemoteDes()=(TAny*)aBuffer;
		m.RemoteDesOffset()=0;		// pre-aligned
		m.DriverFlags() = 0;        

		__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
		OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_WRITE2, "reqId=%d; remote Des=0x%x", (TInt) m.Id(), (TUint) m.RemoteDes());
		OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_WRITE3, "length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()),  (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
		
		__ASSERT_DEBUG(iPrimaryMedia->iBody, LOCM_FAULT());
		TInt mediaChanges = iPrimaryMedia->iBody->iMediaChanges;

		SendToMainQueueDfcAndBlock(&m);		// queues request, sets and opens client thread, queues dfc and blocks thread until request is completed
		
		retVal = m.iValue;

#ifdef __DEBUG_DEMAND_PAGING__
		if (retVal != KErrNone)
			Kern::Printf("Pagout Failure %d, retry %d", retVal, i);
#endif
		// reset retry count if there's ben a media change
		if (retVal != KErrNone && mediaChanges != iPrimaryMedia->iBody->iMediaChanges)
			i = 0;
		}	// for ()

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	NKern::FMWait(&iInstrumentationLock);
	if (iServicingDataOut)
		iServicingDataOut--;
	NKern::FMSignal(&iInstrumentationLock);
#endif

#ifdef __DEMAND_PAGING_BENCHMARKS__
	SPagingBenchmarkInfo& info = iDataOutBenchmarkData;
	TUint32 bmEnd = NKern::FastCounter();
	++info.iCount;
#if !defined(HIGHIGH_RES_TIMER) || defined(HIGH_RES_TIMER_COUNTS_UP)
	TInt64 elapsed=bmEnd-bmStart;
#else
	TInt64 elapsed=bmStart-bmEnd;
#endif
	info.iTotalTime += elapsed;
	if (elapsed > info.iMaxTime)
		info.iMaxTime = elapsed;
	if (elapsed < info.iMinTime)
		info.iMinTime = elapsed;
#endif // __DEMAND_PAGING_BENCHMARKS__
	
	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_WRITE_EXIT2, this, retVal );
	return retVal;
	}


TInt DMediaPagingDevice::DeleteNotify(TThreadMessage* aReq,TUint aOffset,TUint aSize)
	{
	OstTraceFunctionEntry1( DMEDIAPAGINGDEVICE_DELETENOTIFY_ENTRY, this );
	if (iDeleteNotifyNotSupported)
	    {
		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT1, this, KErrNotSupported );
		return KErrNotSupported;
	    }

	__ASSERT_ALWAYS(NKern::CurrentThread()!=iPrimaryMedia->iDfcQ->iThread,LOCM_FAULT());	// that would lock up the system, thus better die now
	__ASSERT_ALWAYS(aReq,LOCM_FAULT());
	__ASSERT_ALWAYS(DataPagingDfcQ(iPrimaryMedia),LOCM_FAULT());
	__ASSERT_CRITICAL

	TUint offset = aOffset<<iReadUnitShift;
	TUint size = aSize<<iReadUnitShift;

#ifdef BTRACE_PAGING_MEDIA
	TInt buf[2];
	buf[0] = size;		// delete notify length
	buf[1] = (TInt)aReq;	// address of request object
	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaLocMedDeleteNotifyBegin,NULL,offset,buf,sizeof(buf));
#endif

	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("DMediaPagingDevice::Write, Req(0x%08x), Offset(%d),Size(%d)",aReq,offset,size));
	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_DELETENOTIFY1 , "req=0x%08x; offset=%d; size=%d", (TUint) aReq, offset, size);
	
	// no DFCQ, media driver executes in the context of calling thread
	if (!iPrimaryMedia->iDfcQ)
		{
		LOCM_FAULT();		// don't allow paging
		OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT2, this, KErrNone );
		return KErrNone;	// keep compiler happy
		}

	TLocDrvRequest& m=*(TLocDrvRequest*)(aReq);


	m.Flags() = TLocDrvRequest::EKernelBuffer | TLocDrvRequest::EPaging  | TLocDrvRequest::EDataPaging;
	m.Id() = DLocalDrive::EDeleteNotify;
	m.Drive() = TheDrives[iDataPagingDriveNumber];

	m.RemoteThread() = NULL;
	m.Pos() = offset;
	m.Length() = Int64(size);
	m.RemoteDes() = NULL;
	m.RemoteDesOffset() = 0;		// pre-aligned
	m.DriverFlags()=0;
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("ReqId=%d, Pos=0x%lx, Len=0x%lx, remote Des 0x%x",m.Id(),m.Pos(),m.Length(),m.RemoteDes()));
	OstTraceDefExt2(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_DELETENOTIFY2 , "reqId=%d; remote Des=0x%x", m.Id(),(TUint) m.RemoteDes());
	OstTraceDefExt4(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DMEDIAPAGINGDEVICE_DELETENOTIFY3 , "length=%x:%x, pos=%x:%x", (TUint) I64HIGH(m.Length()), (TUint) I64LOW(m.Length()), (TUint) I64HIGH(m.Pos()), (TUint) I64LOW(m.Pos()));
	// send request aynchronously as we don't particularly care about the result 
	// and waiting would slow down the thread taking the page fault
	iPrimaryMedia->RequestCountInc();

	m.SendReceive(&iMainQ);	// send  request synchronously

#ifdef __DEMAND_PAGING__
	iPrimaryMedia->RequestCountDec();
#endif

	TInt retVal = m.iValue;

	if (retVal == KErrNotSupported)
		iDeleteNotifyNotSupported = ETrue;

	OstTraceFunctionExitExt( DMEDIAPAGINGDEVICE_DELETENOTIFY_EXIT3, this, retVal );
	return retVal;
	}


EXPORT_C TInt TLocDrvRequest::WriteToPageHandler(const TAny* aSrc, TInt aSize, TInt anOffset)
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_WRITETOPAGEHANDLER_ENTRY, this );
#ifdef BTRACE_PAGING_MEDIA
	TMediaDevice medDev=Drive()->iMedia->iDevice;
	TInt buf[3];
	buf[0]=(TUint32)RemoteDes();
	buf[1]=anOffset;
	buf[2]=aSize;
	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaMedDrvWriteBack,medDev,this,buf,sizeof(buf));
#endif
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("TLocDrvRequest::WriteToPageHandler, memcpy((aTrg)%08x, (aSrc)%08x, (aLength)%08x)",(TUint32)RemoteDes()+anOffset,aSrc,aSize));
	(void)memcpy((TAny*)((TUint32)RemoteDes()+anOffset), aSrc, aSize);	// maybe in later versions this could be something else
	OstTraceFunctionExitExt( TLOCDRVREQUEST_WRITETOPAGEHANDLER_EXIT, this, KErrNone );
	return KErrNone;
	}

EXPORT_C TInt TLocDrvRequest::ReadFromPageHandler(TAny* aDst, TInt aSize, TInt anOffset)
	{
	OstTraceFunctionEntry1( TLOCDRVREQUEST_READFROMPAGEHANDLER_ENTRY, this );
#ifdef BTRACE_PAGING_MEDIA
	TMediaDevice medDev=Drive()->iMedia->iDevice;
	TInt buf[3];
	buf[0]=(TUint32)RemoteDes();
	buf[1]=anOffset;
	buf[2]=aSize;
	BTraceContextN(BTrace::EPagingMedia,BTrace::EPagingMediaMedDrvRead,medDev,this,buf,sizeof(buf));
#endif
	__KTRACE_OPT2(KLOCDRV,KLOCDPAGING,Kern::Printf("TLocDrvRequest::ReadFromPageHandler, memcpy((aDst)%08x, (aTrg)%08x, (aLength)%08x)",aDst,(TUint32)RemoteDes()+anOffset,aSize));
	(void)memcpy(aDst, (TAny*)((TUint32)RemoteDes()+anOffset), aSize);	// maybe in later versions this could be something else
	OstTraceFunctionExitExt( TLOCDRVREQUEST_READFROMPAGEHANDLER_EXIT, this, KErrNone );
	return KErrNone;
	}

_LIT(KLitFragmentationMutexName, "FRAGMENTATION_MUTEX");

TInt DFragmentationPagingLock::Construct(TUint aNumPages)
	{
	OstTraceFunctionEntryExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_ENTRY, this );
	TInt r=KErrNone;
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation Lock: creating Mutex"));
	r=Kern::MutexCreate(this->iFragmentationMutex, KLitFragmentationMutexName, KMutexOrdNone);
	if (r!=KErrNone)
	    {
		OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT1, this, r );
		return r;
	    }
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation Lock: Mutex created OK"));
	OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DFRAGMENTATIONPAGINGLOCK_CONSTRUCT1 , "Fragmentation Lock: Mutex created OK");

	iFragmentGranularity = 0;
	if (aNumPages == 0)
	    {
		OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT2, this, KErrNone );
		return KErrNone;
	    }
	
	// in CS
	TInt pageSize=Kern::RoundToPageSize(1);
	LockFragmentation();
	r=Alloc(pageSize*aNumPages);	// alloc pages
	UnlockFragmentation();

	if(r==KErrNone)
		{
		iFragmentGranularity = pageSize * aNumPages;
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));
		OstTraceDef1(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, DFRAGMENTATIONPAGINGLOCK_CONSTRUCT2, "Fragmentation granularity=0x%x", iFragmentGranularity);
		}

	OstTraceFunctionExitExt( DFRAGMENTATIONPAGINGLOCK_CONSTRUCT_EXIT3, this, r );
	return r;
	}

void DFragmentationPagingLock::Cleanup()
	{
	OstTraceFunctionEntry1( DFRAGMENTATIONPAGINGLOCK_CLEANUP_ENTRY, this );
	// in CS
	if (iFragmentationMutex)
		{
		LockFragmentation();
		Free();					// at last!
		UnlockFragmentation();
		Kern::SafeClose((DObject*&)iFragmentationMutex,NULL);
		}
	OstTraceFunctionExit1( DFRAGMENTATIONPAGINGLOCK_CLEANUP_EXIT, this );
	}

#else
#if !defined(__WINS__)
EXPORT_C TInt TLocDrvRequest::WriteToPageHandler(const TAny* , TInt , TInt)
	{
	return KErrNone;		// stub for def file
	}
#endif // __WINS__
#endif //__DEMAND_PAGING__
/********************************************
 * Media driver base class
 ********************************************/
 
 
 
 
/**
Constructor.

This is called, typically, by a derived class constructor in its ctor list.

@param aMediaId The value of the unique media ID assigned when the media
                driver is registered.
                
@see LocDrv::RegisterMediaDevice()                
*/
EXPORT_C DMediaDriver::DMediaDriver(TInt aMediaId)
	{
	OstTraceFunctionEntryExt( DMEDIADRIVER_DMEDIADRIVER_ENTRY, this );
	
//	iPhysicalDevice=NULL;
//	iTotalSizeInBytes=0;
//	iCurrentConsumption=0;
//	iPrimaryMedia=NULL;
//	iCritical=EFalse;
	iPrimaryMedia=(DPrimaryMediaBase*)TheMedia[aMediaId];
	OstTraceFunctionExit1( DMEDIADRIVER_DMEDIADRIVER_EXIT, this );
	}




/**
Destructor.

Sets the device's current consumption to zero, and calls Close() on
the PDD factory object.

@see DObject::Close()
*/
EXPORT_C DMediaDriver::~DMediaDriver()
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_DMEDIADRIVER_DESTRUCTOR_ENTRY, this );
	SetCurrentConsumption(0);
	Kern::SafeClose((DObject*&)iPhysicalDevice,NULL);
	OstTraceFunctionExit1( DMEDIADRIVER_DMEDIADRIVER_DESTRUCTOR_EXIT, this );
	}




/**
Closes the media driver.

This default implementation simply deletes this DMediaDriver object.

Media drivers can provide their own implementation, which gives them
the opportunity to clean up resources before closure; for example,
cancelling a DFC.
Any replacement function must call this base class function as
the last instruction. 
*/
EXPORT_C void DMediaDriver::Close()
	{
	delete this;
	}




/**
Sets the total size of the media device.

The function must be called by the media driver's implementation of PartitionInfo().

@param aTotalSizeInBytes The total size of the media, in bytes.
@param aLocDrv           This is not used by media drivers; the class
                         definition provides a default value.

@see DMediaDriver::PartitionInfo()
*/
EXPORT_C void DMediaDriver::SetTotalSizeInBytes(Int64 aTotalSizeInBytes, TLocDrv* aLocDrv)
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_SETTOTALSIZEINBYTES_ENTRY, this );
	iTotalSizeInBytes=aTotalSizeInBytes;
	if (aLocDrv)
		aLocDrv->iPartitionLen=aTotalSizeInBytes;
	OstTraceFunctionExit1( DMEDIADRIVER_SETTOTALSIZEINBYTES_EXIT, this );
	}

/**
For non NAND devices, i.e. devices which don't set TLocalDriveCapsV4::iNumOfBlocks,
set iSectorSizeInBytes, iNumberOfSectors & iNumPagesPerBlock appropriately to allow 
TLocalDriveCapsV4::MediaSizeInBytes() to correctly return the media size

Media drivers should call this when they receive a DLocalDrive::ECaps request
*/
EXPORT_C void DMediaDriver::SetTotalSizeInBytes(TLocalDriveCapsV4& aCaps)
	{
	if (aCaps.iNumOfBlocks == 0)
		{
		aCaps.iSectorSizeInBytes = 512;
		aCaps.iNumPagesPerBlock = 1;	// ...to ensure compatibility with NAND semantics
		Int64 numberOfSectors = iTotalSizeInBytes >> 9;
		while (I64HIGH(numberOfSectors) > 0)
			{
			aCaps.iNumPagesPerBlock<<= 1;
			numberOfSectors>>= 1;
			}
		aCaps.iNumberOfSectors = I64LOW(numberOfSectors);
		}
	}



/**
Gets the total size of the media.

@return The total size of the media, in bytes.

@see DMediaDriver::SetTotalSizeInBytes()
*/
EXPORT_C Int64 DMediaDriver::TotalSizeInBytes()
	{
	return iTotalSizeInBytes;
	}




/**
Flags the media driver as entering a critical part of its processing.

In this context, critical means that the driver must be allowed to complete
its current activity.
For example, a request to power down the device must be deferred until
the driver exits the critical part.

@return KErrNone, if the driver has been successfully flagged as being in
        a critical part; otherwise, one of the other system-wide error codes.
        
@see DMediaDriver::EndInCritical()
*/
EXPORT_C TInt DMediaDriver::InCritical()
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_INCRITICAL_ENTRY, this );
	if (!iCritical)
		{
		TInt r=iPrimaryMedia->InCritical();
		if (r!=KErrNone)
		    {
			OstTraceFunctionExitExt( DMEDIADRIVER_INCRITICAL_EXIT, this, r );
			return r;
		    }
		iCritical=ETrue;
		}
	OstTraceFunctionExitExt( DMEDIADRIVER_INCRITICAL_EXIT2, this, KErrNone );
	return KErrNone;
	}




/**
Flags the media driver as leaving a critical part of its processing.

@see DMediaDriver::InCritical()
*/
EXPORT_C void DMediaDriver::EndInCritical()
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_ENDINCRITICAL_ENTRY, this );
	if (iCritical)
		{
		iCritical=EFalse;
		iPrimaryMedia->EndInCritical();
		}
	OstTraceFunctionExit1( DMEDIADRIVER_ENDINCRITICAL_EXIT, this );
	}




/**
@internalComponent
*/
EXPORT_C void DMediaDriver::SetCurrentConsumption(TInt aValue)
	{
	OstTraceFunctionEntryExt( DMEDIADRIVER_SETCURRENTCONSUMPTION_ENTRY, this );
	TInt old = (TInt)__e32_atomic_swp_ord32(&iCurrentConsumption, aValue);
	TInt delta = aValue - old;
	iPrimaryMedia->DeltaCurrentConsumption(delta);
	OstTraceFunctionExit1( DMEDIADRIVER_SETCURRENTCONSUMPTION_EXIT, this );
	}




/**
Informs the media driver subsystem that an asynchronous request is complete.

@param m       The request that this call is completing.
@param aResult The return code for the asynchronous request. Typically, this
               is KErrNone to report success, or one of the other system-wide
               error codes to report failure or other problems.
*/
EXPORT_C void DMediaDriver::Complete(TLocDrvRequest& m, TInt aResult)
	{
	OstTraceExt2( TRACE_FLOW, DMEDIADRIVER_COMPLETE_ENTRY, "m=%x;aResult=%d", (TUint) &m, aResult );
	CHECK_RET(aResult);
#ifdef __DEMAND_PAGING__
	if (DMediaPagingDevice::PagingRequest(m))
		{
		__ASSERT_ALWAYS(iPrimaryMedia && iPrimaryMedia->iPagingMedia && iPrimaryMedia->iBody->iPagingDevice,LOCM_FAULT());
		__ASSERT_ALWAYS( ((m.Flags() & TLocDrvRequest::ECodePaging) == 0) || (m.Drive()->iPagingDrv), LOCM_FAULT());
		DMediaPagingDevice* pagingdevice = iPrimaryMedia->iBody->iPagingDevice;
		pagingdevice->CompleteRequest(&m, aResult);
		}
	else
#endif
	iPrimaryMedia->CompleteRequest(m, aResult);
	
	if (&m == iPrimaryMedia->iCurrentReq)	// Complete() called on request serviced synchronously
		iPrimaryMedia->iCurrentReq = NULL;

	iPrimaryMedia->RunDeferred();
	OstTraceFunctionExit1( DMEDIADRIVER_COMPLETE_EXIT, this );
	}



 
/**
Informs the media driver subsystem that the media driver is open
and has been initialised.

This can be called from the PDD factory function Create(), if opening and
initialising the media driver is synchronous, otherwise it should be called by
the asynchronous media driver function that is responsible for opening and
initialising the driver.

@param anError KErrNone if successful, otherwise one of the other system wide
       error codes.
*/
EXPORT_C void DMediaDriver::OpenMediaDriverComplete(TInt anError)
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMediaDriver::OpenMediaDriverComplete(%d) this %x iPrimaryMedia %x", anError, this, iPrimaryMedia));
	OstTraceDefExt3(OST_TRACE_CATEGORY_RND, TRACE_MEDIACHANGE, DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE, "anError %d this 0x%x iPrimaryMedia 0x%x", anError, (TUint) this, (TUint) iPrimaryMedia);
	DPrimaryMediaBase* pM=iPrimaryMedia;
	pM->iAsyncErrorCode=anError;
	pM->iAsyncDfc.Enque();
	OstTraceFunctionExit1( DMEDIADRIVER_OPENMEDIADRIVERCOMPLETE_EXIT, this );
	}




/**
Informs the media driver subsystem that the media driver has completed
the provision of partition information.

The media driver provides partition information in its implementation
of PartitionInfo().

@param anError KErrNone if successful, otherwise one of the other system wide
       error codes.

@see DMediaDriver::PartitionInfo()
*/
EXPORT_C void DMediaDriver::PartitionInfoComplete(TInt anError)
	{
	OstTraceFunctionEntry1( DMEDIADRIVER_PARTITIONINFOCOMPLETE_ENTRY, this );
	__KTRACE_OPT(KLOCDRV,Kern::Printf("DMediaDriver::PartitionInfoComplete(%d) anError %d this %x iPrimaryMedia %x", anError, this, iPrimaryMedia));
	OstTraceExt3( TRACE_INTERNALS, DMDEDIADRIVER_PARTITIONINFOCOMPLETE, "anError=%d; this=%x; iPrimaryMedia=%x", anError, (TUint) this, (TUint) iPrimaryMedia );
	DPrimaryMediaBase* pM=iPrimaryMedia;
	pM->iAsyncErrorCode=anError;
	pM->iAsyncDfc.Enque();
	OstTraceFunctionExit1( DMEDIADRIVER_PARTITIONINFOCOMPLETE_EXIT, this );
	}




/**
@internalComponent
*/
// Default implementation
EXPORT_C void DMediaDriver::Disconnect(DLocalDrive* aLocalDrive, TThreadMessage* aMsg)
	{
	OstTraceFunctionEntryExt( DMEDIADRIVER_DISCONNECT_ENTRY, this );
	// don't need to worry about DLocalDrive going away
	aLocalDrive->Deque();

	aMsg->Complete(KErrNone, EFalse);
	OstTraceFunctionExit1( DMEDIADRIVER_DISCONNECT_EXIT, this );
	}




/**
Registers a media driver with the Local Media Subsystem, and provides
information about the number of supported drives, partitions,
names and drive numbers.

@param aDevice       The unique Media ID for this device.
                     This can take one of the enumerated values defined
                     by the TMediaDevice enum.
@param aDriveCount   Specifies the number of local drive objects to be assigned
                     to the media driver. Drives that support more than one
                     partition must specify a number greater than 1.
@param aDriveList    A pointer to an array of TInt values, which define
                     the drive numbers that are to be allocated to each partition.
                     0 signifies Drive C, 1 signifies drive D, etc. For example,
                     to allocate drive letters J and K, specify an array
                     containing the values [7,8].
                     Note that the size of this array must be the same as the value 
                     specified by aDriveCount.
@param aPrimaryMedia A pointer to the primary DPrimaryMedia object to be
                     associated with the media. This object is responsible for
                     the overall state of the media, i.e. powering up, reading
                     partition information etc. It also has overall control over
                     all partitions as represented by the additional (aNumMedia-1)
                     DMedia objects. 
@param aNumMedia     Specifies the total number of DMedia objects to be
                     associated with the media driver. This number includes the
                     primary DPrimaryMedia object referred to by aPrimaryMedia,
                     plus all of the DMedia objects that are created for each
                     additional drive, and which hold basic information about
                     partitions.
@param aName         The name of the media driver, for example: PCCard
       
@return              KErrNone, if successful;
                     KErrInUse, if a drive is already in use;
                     KErrNoMemory, if there is insufficient memory;
                     or one of the other system-wide error codes.  
*/
EXPORT_C TInt LocDrv::RegisterMediaDevice(TMediaDevice aDevice, TInt aDriveCount, const TInt* aDriveList, DPrimaryMediaBase* aPrimaryMedia, TInt aNumMedia, const TDesC& aName)
	{
	OstTraceFunctionEntry0( LOCDRV_REGISTERMEDIADEVICE_ENTRY );
	// Create TLocDrv / DMedia objects to handle a media device
	__KTRACE_OPT(KBOOT,Kern::Printf("RegisterMediaDevice %S dev=%1d #drives=%d 1st=%d PM=%08x #media=%d",&aName,aDevice,aDriveCount,*aDriveList,aPrimaryMedia,aNumMedia));
	OstTraceExt5( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE1, "aDevice=%d; aDriveCount=%d; aDriveList=%d; aPrimaryMedia=0x%08x; aNumMedia=%d", (TInt) aDevice, (TInt) aDriveCount, (TInt) *aDriveList, (TUint) aPrimaryMedia, (TInt) aNumMedia );

	if (UsedMedia+aNumMedia>KMaxLocalDrives)
	    {
		OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT1, "< KErrInUse");
		return KErrInUse;
		}

	// make a local copy of the name
	HBuf* pN=HBuf::New(aName);
	if (!pN)
	    {
        OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT3, "< KErrNoMemory");
		return KErrNoMemory;
		}

	// Register the primary media and any secondary media
	TInt lastMedia = UsedMedia+aNumMedia-1;
	TInt i;
	TInt r=0;
	for (i=UsedMedia; i<=lastMedia; ++i)
		{
		if (i==UsedMedia)
			TheMedia[i]=aPrimaryMedia;
		else
			TheMedia[i]=new DMedia;
		if (!TheMedia[i])
		    {
             OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT4, "< KErrNoMemory");
			return KErrNoMemory;
		    }
		r=TheMedia[i]->Create(aDevice,i,lastMedia);
		__KTRACE_OPT(KBOOT,Kern::Printf("Media %d Create() returns %d",i,r));
		OstTraceExt2( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE3, "Media=%d Create(); retval=%d", i, r );
		if (r!=KErrNone)
		    {
            OstTrace1(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT5, "< retval=%d", r);
			return r;
		    }
		}
	__KTRACE_OPT(KBOOT,Kern::Printf("FirstMedia %d LastMedia %d",UsedMedia,lastMedia));
	OstTraceExt2( TRACE_INTERNALS, LOCDRV_REGISTERMEDIADEVICE4, "FirstMedia=%d; LastMedia=%d", UsedMedia, lastMedia );
	UsedMedia+=aNumMedia;

	if (__IS_EXTENSION(aDevice))
		aPrimaryMedia->iBody->iMediaExtension = ETrue;

	// Register the drives
	const TInt* p=aDriveList;
	for (i=0; i<aDriveCount; ++i)
		{
		TInt drv = *p++;
		// -1 means not used; this is to enable Dual-slot MMC support 
		if (drv == -1)
			continue;

		__KTRACE_OPT(KBOOT,Kern::Printf("Registering drive %d", drv));
		if (!__IS_EXTENSION(aDevice) && TheDrives[drv])
			{
			__KTRACE_OPT(KBOOT,Kern::Printf("Drive %d already in use", drv));
			return KErrInUse;
			}
		else if (__IS_EXTENSION(aDevice) && !TheDrives[drv])
			{
			__KTRACE_OPT(KBOOT,Kern::Printf("Drive %d not initialized", drv));
			return KErrNotReady;
			}

		TLocDrv* pNewDrive = new TLocDrv(drv);
		if (!pNewDrive)
			{
            OstTrace0(TRACE_FLOW, LOCDRV_REGISTERMEDIADEVICE_EXIT6, "< KErrNoMemory");
			return KErrNoMemory;
			}


		TLocDrv* pOldDrive = TheDrives[drv];
		aPrimaryMedia->iBody->iRegisteredDriveMask|= (0x1 << drv);
		pNewDrive->iNextDrive = pOldDrive;

		TheDrives[drv] = pNewDrive;
		DriveNames[drv] = pN;
		pNewDrive->iPrimaryMedia = aPrimaryMedia;


		if (pOldDrive)
			{
			TInt r = pOldDrive->iPrimaryMedia->Connect(pNewDrive);
			if (r != KErrNone)
				return r;

#ifdef __DEMAND_PAGING__
			// If we've hooked a drive letter which is being used for ROM paging by a media driver
			// which does not report the ROM partition, then we need to change iFirstLocalDriveNumber
			// so that ROM page-in requests go directly to that driver
			DMediaPagingDevice* oldPagingDevice = pOldDrive->iPrimaryMedia->iBody->iPagingDevice;
			if (oldPagingDevice && 
				(oldPagingDevice->iType & DPagingDevice::ERom) &&
				oldPagingDevice->iRomPagingDriveNumber == KErrNotFound && 
				oldPagingDevice->iFirstLocalDriveNumber == drv)
				{
				__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("TRACE: hooking ROM paging device with no defined ROM partition"));
				TInt n;
				for (n=0; n<KMaxLocalDrives; ++n)
					{
					if(TheDrives[n] && TheDrives[n]->iPrimaryMedia == pOldDrive->iPrimaryMedia)
						{
						__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("TRACE: Changing iFirstLocalDriveNumber from %d to %d", oldPagingDevice->iFirstLocalDriveNumber, n));
						oldPagingDevice->iFirstLocalDriveNumber = n;
						break;
						}
					}
				__ASSERT_ALWAYS(n < KMaxLocalDrives, LOCM_FAULT());
				}
#endif

			}

		__KTRACE_OPT(KBOOT,Kern::Printf("Drive %d: TLocDrv @ %08x",drv,pNewDrive));
		}


	OstTraceFunctionExit0( LOCDRV_REGISTERMEDIADEVICE_EXIT7 );
	return KErrNone;
	}




/**
A utility function that is used internally to register the specified
password store.

The password store is used to save passwords for local media.

@param aStore A pointer to the password store to be registered.

@return KErrNone, if successful;
        KErrAlreadyExists, if a password store has already been registered.
*/ 
EXPORT_C TInt LocDrv::RegisterPasswordStore(TPasswordStore* aStore)
	{
	OstTraceFunctionEntry0( LOCDRV_REGISTERPASSWORDSTORE_ENTRY );
	// Create TLocDrv / DMedia objects to handle a media device
	__KTRACE_OPT(KBOOT,Kern::Printf("RegisterPasswordStore"));
	
	TInt r = KErrNone;

	if(ThePasswordStore == NULL)
		ThePasswordStore = aStore;
	else
		r = KErrAlreadyExists;
	OstTrace1(TRACE_INTERNALS, LOCDRV_REGISTERPASSWORDSTORE, "retval=%d", r);
	OstTraceFunctionExit0( LOCDRV_REGISTERPASSWORDSTORE_EXIT );
	return r;
	}

/**
Returns a pointer to the registered password store.

The password store is used to save passwords for local media.

@return A pointer to the registered password store.
*/ 
EXPORT_C TPasswordStore* LocDrv::PasswordStore()
	{
	return ThePasswordStore;
	}

#ifdef __DEMAND_PAGING__
/**
Registers a paging device with the Local Media Subsystem, and provides
information about drive numbers used in Code Paging.

@param aPrimaryMedia A pointer to the primary DPrimaryMedia object associated 
					 with the media.
@param aPagingDriveList    A pointer to an array of TInt values, which define
                     the drive numbers used as Code backup in Code Paging, which
					 are the target of Page In requests. For NAND these will
					 will be usually associated with ROFS and/or User Data drives.
					 In ROM pagigng systems no drive is specified, it is assumed
					 a fixed media for which no non-primary media exists, will be 
					 used.
@param aDriveCount   Specifies the number of local drives associated with this
					 media device which can be used for code paging. 
@param aPagingType	 Identifies the type of Paging this media device is capable
					 of servicing.
@param aReadShift	 Log2 of the read unit size. A read unit is the number of bytes
					 which the device can optimally read from the underlying media.
					 E.g. for small block NAND, a read unit would be equal to the 
					 page size,	512 bytes, therefore iReadShift would be set to 9.
@param aNumPages     The number of pages to alloc for each drive associated with this
					 media driver. The pages are used in request fragmentation.

@return              KErrNone, if successful;
					 KErrNotFound, if at least one of the drive numbers
					 specified has not yet been mapped.
					 KErrArgument, if the passed in an invalid argument.
					 KErrNotSupported, if at least one of the drive numbers 
					 specifed is not associated with this Primary Media.
                     KErrNoMemory, if there is insufficient memory;
                     or one of the other system-wide error codes.  
*/
EXPORT_C TInt LocDrv::RegisterPagingDevice(DPrimaryMediaBase* aPrimaryMedia, const TInt* aPagingDriveList, TInt aDriveCount, TUint aPagingType, TInt aReadShift, TUint aNumPages)
	{
	OstTraceFunctionEntry0( LOCDRV_REGISTERPAGINGDEVICE_ENTRY );
//	SETDEBUGFLAG(KLOCDPAGING);
	
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf(">RegisterPagingDevice: paging type=%d PM=0x%x read shift=%d",aPagingType,aPrimaryMedia,aReadShift));
	OstTraceDefExt3( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE1, "aPagingType=%d; aPrimaryMedia=0x%x; aReadShift=%d", (TInt) aPagingType, (TUint) aPrimaryMedia, (TInt) aReadShift);
	
	TInt i = 0;

	if(!aPagingType || (aPagingType&~(DPagingDevice::ERom | DPagingDevice::ECode | DPagingDevice::EData)))
		{
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Unsupported paging type, exiting"));
		OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT1, "< Unsupported paging type; KErrArgument");
		return KErrArgument;
		}


	// Check for duplicate drives
	if (!aPrimaryMedia->iBody->iMediaExtension)
		{
		for(i=0; i<KMaxLocalDrives; i++)
			{
			if (ThePagingDevices[i] == NULL)
				continue;
			if ((ThePagingDevices[i]->iType&DPagingDevice::ERom) &&	(aPagingType & DPagingDevice::ERom))
				{
				aPagingType&=~DPagingDevice::ERom;		// already have a ROM paging device
				__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Already has ROM pager on locdrv no %d",i));
				}
			if ((ThePagingDevices[i]->iType&DPagingDevice::EData) && (aPagingType & DPagingDevice::EData))
				{
				aPagingType&=~DPagingDevice::EData;		// already have a Data paging device
				__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Already has Data pager on locdrv no %d",i));
				}
			}
		}


	if (aPagingType == 0)
		{
		// there's already a ROM or Data paging device & this doesn't support code paging so quietly exit without further addo
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Nothing left to register on locdrv no %d, exiting",i));
		OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT2, "< Nothing left to register on locdrv no %d; KErrNone",i);
		return KErrNone;
		}

	const TInt* p=aPagingDriveList;
	if(aPagingType&DPagingDevice::ECode)	// supports code paging, do argument check
		{
		if(!aDriveCount || (aDriveCount>=KMaxLocalDrives))
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive count: %d", aDriveCount));
			OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT3, "< Invalid code paging drive count=%d; KErrArgument", aDriveCount);
			return KErrArgument;
			}

		TInt drvCount=0;
		for(i=0; i<KMaxLocalDrives; i++)
			if(TheDrives[i] && TheDrives[i]->iPrimaryMedia==aPrimaryMedia)
				drvCount++;
		if(aDriveCount>drvCount)	// can't exceed number of drives registered by this device
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive count=%d; total=%d", aDriveCount, drvCount));
			OstTraceExt2(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT4, "< Invalid code paging drive count=%d; total=%d; KErrArgument", aDriveCount, drvCount);
			return KErrArgument;
			}

		for (i=0; i<aDriveCount; ++i)
			{
			__KTRACE_OPT(KBOOT,Kern::Printf("RegisterPagingDevice: registering drive=%d ",*p));
			OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE2, "Registering Drive=%d", *p );
			TInt drv=*p++;
			if(drv>=KMaxLocalDrives)
				{
				__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Invalid code paging drive number: %d", drv));
				OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT5, "< Invalid code paging drive number=%d; KErrArgument", drv);
				return KErrArgument;
				}
			TLocDrv* pD=TheDrives[drv];
			if (!pD)
			    {
                OstTrace0(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT6, "< KErrNotFound");
				return KErrNotFound;
			    }
			if (pD->iPrimaryMedia!=aPrimaryMedia)
			    {
                OstTrace0(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT7, "< KErrNotSupported");
				return KErrNotSupported;
			    }
			}
		}


	TInt firstLocalDriveNumber = KErrNotFound; 
	TInt romPagingDriveNumber = KErrNotFound;

	TInt dataPagingDriveNumber = KErrNotFound;
	TInt swapSize = 0;
	TInt blockSize = 0;
	TUint16 flags = 0;

	// find the local drive assocated with the primary media
	for (i=0; i<KMaxLocalDrives; ++i)
		{
		if(TheDrives[i] && TheDrives[i]->iPrimaryMedia == aPrimaryMedia)
			{
			firstLocalDriveNumber = i;
			break;
			}
		}
	__ASSERT_ALWAYS(i < KMaxLocalDrives, LOCM_FAULT());
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("DMediaPagingDevice(), firstLocalDriveNumber %d", firstLocalDriveNumber));
	OstTraceDef1( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE3, "firstLocalDriveNumber=%d", firstLocalDriveNumber );
	
	// Send an ECaps message to wake up the media driver & ensure all partitions are 
	// reported, then search for paged-data or paged-ROM partitions
	// NB: older media drivers supporting ROM and/or code paging only may not have started their DFC queues, 
	// so for these media drivers, use the first local drive supported for ROM-pagin-in  requests and
	// assume the media driver itself will adjust the request position internally to match the ROM partition
	// @see DMediaPagingDevice::Read()
	if ((aPagingType & DPagingDevice::EData) ||
		(aPagingType & DPagingDevice::ERom && aPrimaryMedia->iDfcQ && aPrimaryMedia->iMsgQ.iReady))
		{
		// the message queue must have been started already (by the media driver calling iMsgQ.Receive())
		// otherwise we can't send the DLocalDrive::ECaps request
		if (!aPrimaryMedia->iDfcQ || !aPrimaryMedia->iMsgQ.iReady)
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: Message queue not started"));
			OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT8, "< RegisterPagingDevice: Message queue not started; KErrNotReady");
			return KErrNotReady;
			}


		TLocDrvRequest m;
        TBuf8<KMaxLocalDriveCapsLength> capsBuf;
        
		memclr(&m, sizeof(m));
		
		// Get the Caps from the device. NB for MMC/SD we may need to retry as some PSLs start up
		// in "door open" or "media not present" state which can result in the cancellation of requests
		TInt i;
		const TInt KRetries = 5;
		TInt r = KErrNotReady;
		for (i=0; r == KErrNotReady && i < KRetries; i++)
			{
			capsBuf.SetMax();
			capsBuf.FillZ();
			m.Drive() = TheDrives[firstLocalDriveNumber];
			m.Id() = DLocalDrive::ECaps;
			m.RemoteDes() = (TAny*)capsBuf.Ptr();	// overload this
			m.Length() = KMaxLocalDriveCapsLength;	// for pinning
			r = aPrimaryMedia->Request(m);

//Kern::Printf("EQueryPageDeviceInfo: i %d: r %d ", i, r);
			__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Paging device ECaps: i %d: r %d ", i, r));
			OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE4, "Paging device ECaps: i %d retval=%d", i, r);
			}

		if (r != KErrNone)
		    {
            OstTrace1(TRACE_FLOW, LOCRV_REGISTERPAGINGDEVICE_EXIT9, "< retval=%d",r);
            // Media driver failure; media maybe recoverable after boot.
            // Can't register any page drives so return not supported.
			return KErrNotSupported;
		    }

		TLocalDriveCapsV6& caps = *(TLocalDriveCapsV6*)capsBuf.Ptr();
		blockSize = caps.iBlockSize;
		
		TLocDrv* drive;
		for (i=0; i<KMaxLocalDrives; ++i)
			{
			drive = TheDrives[i];
			if(drive && drive->iPrimaryMedia == aPrimaryMedia)
				{
				__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("RegisterPagingDevice: local drive %d, partition type %x base %lx size %lx name %S", i, drive->iPartitionType, drive->iPartitionBaseAddr, drive->iPartitionLen, DriveNames[i] ? DriveNames[i] : &KNullDesC8));
				// ROM partition ?
				if ((romPagingDriveNumber == KErrNotFound) && 
					(drive->iPartitionType == KPartitionTypeROM) &&
					(aPagingType & DPagingDevice::ERom))
					{
					__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Found ROM partition on local drive %d, size %x", i, I64LOW(drive->iPartitionLen)));
					OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE5, "Found ROM partition on local drive=%d; size=0x%x", (TInt) i, (TUint) I64LOW(drive->iPartitionLen));
					romPagingDriveNumber = i;
					}
			    // swap partition ?
				else if ((dataPagingDriveNumber == KErrNotFound) && 
					(drive->iPartitionType == KPartitionTypePagedData) &&
					(aPagingType & DPagingDevice::EData))
					{
					__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Found swap partition on local drive %d, size %x", i, I64LOW(drive->iPartitionLen)));
					OstTraceDefExt2( OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE6, "Found SWAP partition on local drive=%d; size=0x%x", (TInt) i, (TUint) I64LOW(drive->iPartitionLen) );			
					dataPagingDriveNumber = i;
					TheDataPagingDrive = drive;
					swapSize = drive->iPartitionLen >> aReadShift;
					
			        // Mark Paging Device capable of utilising physical addresss only accesses
			        if (drive->iDmaHelper)
			            flags |= DPagingDevice::ESupportsPhysicalAccess;  
					}
				}
			}

		if (swapSize == 0)
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("Disabling data paging"));
			OstTraceDef0(OST_TRACE_CATEGORY_RND, TRACE_DEMANDPAGING, LOCDRV_REGISTERPAGINGDEVICE7, "Disabling data paging");
			aPagingType &= ~DPagingDevice::EData;
			}

		}


	// create and set up a DPagingDevice to allow PageIn request servicing
	DMediaPagingDevice* pagingDevice = new DMediaPagingDevice(aPrimaryMedia);
	if(!pagingDevice)
		{
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not create paging device"));
		OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT_EXIT10, "< RegisterPagingDevice: could not create paging device; KErrNoMemory");
		return KErrNoMemory;
		}

	pagingDevice->iType = aPagingType;
	if (aPrimaryMedia->iBody->iMediaExtension)
		pagingDevice->iType|= DPagingDevice::EMediaExtension;

	pagingDevice->iReadUnitShift = aReadShift;

	pagingDevice->iFirstLocalDriveNumber = firstLocalDriveNumber;
	pagingDevice->iRomPagingDriveNumber = romPagingDriveNumber;

	pagingDevice->iDataPagingDriveNumber = dataPagingDriveNumber;
	pagingDevice->iSwapSize = swapSize;
		
	pagingDevice->iPreferredWriteShift = (blockSize) ? __e32_find_ms1_32(blockSize) : 0;

#ifdef __DEBUG_DEMAND_PAGING__
	Kern::Printf("PagingDevice :");
	Kern::Printf("Name %S", firstLocalDriveNumber >= 0 && DriveNames[firstLocalDriveNumber] ? DriveNames[firstLocalDriveNumber] : &KNullDesC8);
	Kern::Printf("iType 0x%x", pagingDevice->iType);
	Kern::Printf("iFlags 0x%x\n", pagingDevice->iFlags);
	Kern::Printf("iReadUnitShift 0x%x", pagingDevice->iReadUnitShift);
	Kern::Printf("iFirstLocalDriveNumber 0x%x", pagingDevice->iFirstLocalDriveNumber);
	Kern::Printf("iRomPagingDriveNumber 0x%x", pagingDevice->iRomPagingDriveNumber);
	Kern::Printf("iDataPagingDriveNumber 0x%x", pagingDevice->iDataPagingDriveNumber);
	Kern::Printf("iSwapSize 0x%x", pagingDevice->iSwapSize);
	Kern::Printf("iPreferredWriteShift 0x%x\n", pagingDevice->iPreferredWriteShift);
#endif


	// This table is indexed by DPagingDevice::TType
	const char* DeviceName[] = 
		{
		"Error",
		"RomPagingDevice",
		"CodePagingDevice",
		"RomAndCodePagingDevice",
		"DataPagingDevice",
		"RomAndDataPagingDevice",
		"CodeAndDataPagingDevice",
		"RomAndCodeAndDataPagingDevice"
		};


	if(aPagingType & DPagingDevice::ECode)
		{
		for (i=0; i<aDriveCount; ++i)
			pagingDevice->iDrivesSupported |= (0x1<<aPagingDriveList[i]);
		}
	pagingDevice->iName = DeviceName[aPagingType];

	// If ThePinObjectAllocator has already been created with a smaller number of pages,
	// delete it & then re-create it
	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: ThePinObjectAllocator %x", ThePinObjectAllocator));
	if (ThePinObjectAllocator && ThePinObjectAllocator->iFragmentGranularity < Kern::RoundToPageSize(1) * aNumPages)
		{
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: Recreating ThePinObjectAllocator..."));
		delete ThePinObjectAllocator;
		ThePinObjectAllocator = NULL;
		}


	TInt r;
	if (ThePinObjectAllocator == NULL)
		{
		ThePinObjectAllocator = new DPinObjectAllocator();
		if(!ThePinObjectAllocator)
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not create ThePinObjectAllocator"));
			OstTrace0(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT11, "RegisterPagingDevice: could not create ThePinObjectAllocator; KErrNoMemory");
			return KErrNoMemory;
			}
		r = ThePinObjectAllocator->Construct(KDynamicPagingLockCount, aNumPages);
		if (r != KErrNone)
			{
			__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not construct ThePinObjectAllocator"));
			OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT12, "< RegisterPagingDevice: could not construct ThePinObjectAllocator; retval=%d",r);
			return r;
			}
		}


	// Register our DPagingDevice with the Kernel
	r=Kern::InstallPagingDevice(pagingDevice);

#ifdef __DEBUG_DEMAND_PAGING__
	Kern::Printf("Kern::InstallPagingDevice() r %d", r);
#endif

	if (r!=KErrNone)
		{
		__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("RegisterPagingDevice: could not install paging device"));
		OstTrace1(TRACE_FLOW, LOVDRV_REGISTERPAGINGDEVICE_EXIT13, "< RegisterPagingDevice: could not install paging device; retval=%d", r);
		delete pagingDevice;
		return r;
		}

	// all hunky dory, save paging device and mark our media as pageable
	ThePagingDevices[aPrimaryMedia->iMediaId] = pagingDevice;	// association created between PrimaryMedia and PagingDevice via iMediaId
	aPrimaryMedia->iPagingMedia = 1;

	// mark our drives as pageable
	p=aPagingDriveList;
	if (aPagingType&DPagingDevice::ECode)
		{
		for (i=0; i<aDriveCount; ++i)
			{
			TLocDrv* pD=TheDrives[*p++];
			pD->iPagingDrv = 1;
			// mark all attached drives as pageable too - this is really 
			// only to avoid hitting an ASSERT in DMediaDriver::Complete()
			while (pD->iNextDrive)
				{
				pD->iNextDrive->iPagingDrv = 1;
				pD = pD->iNextDrive;
				}
			}
		}

	// Flags to indicate that a paging device is registered and pinning of user requests may be required
	aPrimaryMedia->iPagingMedia = 1;

	// point the primary media to the paging device
	aPrimaryMedia->iBody->iPagingDevice = pagingDevice;

	if (aPagingType & DPagingDevice::ERom)
		{
		aPrimaryMedia->iRomPagingMedia = 1;
		TheRomPagingMedia = aPrimaryMedia;
		}
	
	// Is data paging enabled in this ROM ?
	TInt memModelAttributes = Kern::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);
	TBool dataPagingSupported = memModelAttributes & EMemModelAttrDataPaging;
#ifdef __DEBUG_DEMAND_PAGING__
	Kern::Printf("memModelAttributes %08X", memModelAttributes);
	Kern::Printf("DataPagingSupported %d", dataPagingSupported);
#endif
	if (!dataPagingSupported)
		{
#ifdef __DEBUG_DEMAND_PAGING__
		if (aPagingType & DPagingDevice::EData)
		    {
			Kern::Printf("Disabling data paging, not supported in this ROM");
		    }
#endif
		aPagingType&= ~DPagingDevice::EData;
		}


	if (aPagingType & DPagingDevice::EData)
		{
		DataPagingDeviceRegistered = ETrue;
		aPrimaryMedia->iDataPagingMedia = 1;
		TheDataPagingMedia = aPrimaryMedia;
		}

	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("< RegisterPagingDevice"));
	OstTraceFunctionExit0( LOCDRV_REGISTERPAGINGDEVICE_EXIT14 );
//	CLRDEBUGFLAG(KLOCDPAGING);
	return KErrNone;
	}

#else //__DEMAND_PAGING__

#if !defined(__WINS__)
EXPORT_C TInt LocDrv::RegisterPagingDevice(DPrimaryMediaBase* , const TInt* , TInt , TUint , TInt , TUint )
	{
	return KErrNotSupported;
	}		// stub for def file
#endif // __WINS__

#endif //__DEMAND_PAGING__


/**
Registers a media device with physical memory addressing capabilities with the
Local Media Subsystem.

@param aPrimaryMedia A pointer to the primary DPrimaryMedia object associated 
					 with the media device.
@param aMediaBlockSize The Minimum transfer size (bytes) for the media device.
@param aDmaMaxAddressable The Maximum Addressing Range for the media device's DMA controller, 0 if None.				 
@param aDmaAlignment The required memory alignment for the media device's DMA controller.

@return KErrNone, Always;
*/
EXPORT_C TInt LocDrv::RegisterDmaDevice(DPrimaryMediaBase* aPrimaryMedia, 
										TInt aMediaBlockSize,				// Minimum transfer size (bytes) for the media
										TInt aDmaMaxAddressable,			// Max Addressing Range for DMA controller, 0 if None.
										TInt aDmaAlignment)					// DMA Alignment e.g. word alignment required = 2
	{
	OstTraceFunctionEntry0( LOCDRV_REGISTERDMADEVICE_ENTRY );
	
	__KTRACE_OPT(KBOOT ,Kern::Printf("RegisterPhysicalAddrDevice: PM=0x%x BS=%d MaxAddr=%d DMA=%d", 
									aPrimaryMedia, aMediaBlockSize, aDmaMaxAddressable, aDmaAlignment));
	OstTraceExt4( TRACE_INTERNALS, LOCDRV_REGISTERDMADEVICE, "aPrimaryMedia=0x%x; aMediaBlockSize=%d; aDmaMaxAddressable=%d; aDmaAlignment=%d", (TUint) aPrimaryMedia, (TInt) aMediaBlockSize, (TInt) aDmaMaxAddressable, (TInt) aDmaAlignment );
	
	for (TInt i=0; i<KMaxLocalDrives; ++i)
		{
		TLocDrv* pL=TheDrives[i];
		if (pL && pL->iPrimaryMedia == aPrimaryMedia && pL->iDmaHelper == NULL)
			{
			pL->iDmaHelper = new DDmaHelper;
			__ASSERT_ALWAYS(pL != NULL, LOCM_FAULT());
			
			// if no limit stated on addressing range use 1MB
			TInt MaxAddress = aDmaMaxAddressable ? (1024*1024) : aDmaMaxAddressable;
			
			TInt r = pL->iDmaHelper->Construct(MaxAddress, aMediaBlockSize, aDmaAlignment);
			__ASSERT_ALWAYS(r == KErrNone, LOCM_FAULT());
			}
		}

	OstTraceFunctionExit0( LOCDRV_REGISTERDMADEVICE_EXIT );
	return KErrNone;
	}

void GetDriveInfo(TDriveInfoV1& info)
	{
	OstTraceFunctionEntry1( GETDRIVEINFO_ENTRY, ( TUint )&( info ) );
	TInt i;
	TInt drives=0;
	TUint32 sock_mask=0;
	TInt sockets=0;

	info.iRegisteredDriveBitmask = 0;

	for (i=0; i<KMaxPBusSockets; ++i)
		info.iSocketName[i].Zero();
	for (i=0; i<KMaxLocalDrives; ++i)
		{
		TLocDrv* pL=TheDrives[i];
		if (pL)
			{
			pL = TDriveIterator::GetPhysicalDrive(TheDrives[i]);
			++drives;
			TInt sockNum;
			DPrimaryMediaBase* pM=pL->iPrimaryMedia;
			if (pM->IsRemovableDevice(sockNum))
				{
				if (!(sock_mask & (1<<sockNum)))
					{
					info.iSocketName[sockNum]=*DriveNames[i];
					__KTRACE_OPT(KLOCDRV,Kern::Printf("Socket %d device %d name %S", sockNum, pM->iDevice, DriveNames[i]));
					OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO1, "Socket=%d; device=%d", sockNum, (TUint) pM->iDevice );
					if ( (sockNum + 1) > sockets )
						sockets = sockNum + 1;
					}
				sock_mask |= (1<<sockNum);
				}
			info.iDriveName[i]=*DriveNames[i];
			__KTRACE_OPT(KLOCDRV,Kern::Printf("Drive %d device %d name %S",i,pM->iDevice,DriveNames[i]));
			OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO2, "Drive=%d; device=%d", i, (TUint) pM->iDevice );
			
			info.iRegisteredDriveBitmask |= (0x01 << i);
			}
		}
	info.iTotalSupportedDrives=drives;
	info.iTotalSockets=sockets;
	info.iRuggedFileSystem=ETrue;
	__KTRACE_OPT(KLOCDRV,Kern::Printf("Total drives=%d, sockets=%d",drives,sockets));
	OstTraceExt2( TRACE_INTERNALS, GETDRIVEINFO3, "Total drives=%d; sockets=%d", drives, sockets );
	OstTraceFunctionExit0( GETDRIVEINFO_EXIT );
	}

#if defined(__DEMAND_PAGING__) && defined(__CONCURRENT_PAGING_INSTRUMENTATION__)
void ResetConcurrencyStats(DMediaPagingDevice* aDevice, TMediaPagingStats aStats)
	{
	NKern::FMWait(&aDevice->iInstrumentationLock);
	switch(aStats)
		{
		case EMediaPagingStatsRom:
			aDevice->iServicingROM=0;
			memclr(&aDevice->iROMStats,sizeof(SMediaROMPagingConcurrencyInfo));
			break;
		case EMediaPagingStatsCode:
			aDevice->iServicingCode=0;
			memclr(&aDevice->iCodeStats,sizeof(SMediaCodePagingConcurrencyInfo));
			break;
		case EMediaPagingStatsDataIn:
			aDevice->iServicingDataIn=0;
			memclr(&aDevice->iDataStats,sizeof(SMediaDataPagingConcurrencyInfo));
			break;
		case EMediaPagingStatsDataOut:
			aDevice->iServicingDataOut=0;
			memclr(&aDevice->iDataStats,sizeof(SMediaDataPagingConcurrencyInfo));
			break;
		case EMediaPagingStatsAll:
			aDevice->iServicingROM=0;
			aDevice->iServicingCode=0;
			aDevice->iServicingDataIn=0;
			aDevice->iServicingDataOut=0;
			memclr(&aDevice->iROMStats,sizeof(SMediaROMPagingConcurrencyInfo));
			memclr(&aDevice->iCodeStats,sizeof(SMediaCodePagingConcurrencyInfo));
			memclr(&aDevice->iDataStats,sizeof(SMediaDataPagingConcurrencyInfo));
			break;
		}
	NKern::FMSignal(&aDevice->iInstrumentationLock);
	}
#endif
#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)
void ResetBenchmarkStats(DMediaPagingDevice* aDevice, TMediaPagingStats aStats)
	{
	NKern::FMWait(&aDevice->iInstrumentationLock);
	switch(aStats)
		{
		case EMediaPagingStatsRom:
			aDevice->iROMBenchmarkData.iCount = 0;
			aDevice->iROMBenchmarkData.iTotalTime = 0;
			aDevice->iROMBenchmarkData.iMaxTime = 0;
			aDevice->iROMBenchmarkData.iMinTime = KMaxTInt;
			break;
		case EMediaPagingStatsCode:
			aDevice->iCodeBenchmarkData.iCount = 0;
			aDevice->iCodeBenchmarkData.iTotalTime = 0;
			aDevice->iCodeBenchmarkData.iMaxTime = 0;
			aDevice->iCodeBenchmarkData.iMinTime = KMaxTInt;
			break;
		case EMediaPagingStatsDataIn:
			aDevice->iDataInBenchmarkData.iCount = 0;
			aDevice->iDataInBenchmarkData.iTotalTime = 0;
			aDevice->iDataInBenchmarkData.iMaxTime = 0;
			aDevice->iDataInBenchmarkData.iMinTime = KMaxTInt;
			break;
		case EMediaPagingStatsDataOut:
			aDevice->iDataOutBenchmarkData.iCount = 0;
			aDevice->iDataOutBenchmarkData.iTotalTime = 0;
			aDevice->iDataOutBenchmarkData.iMaxTime = 0;
			aDevice->iDataOutBenchmarkData.iMinTime = KMaxTInt;
			break;
		case EMediaPagingStatsAll:
			aDevice->iDataInBenchmarkData.iCount = 0;
			aDevice->iDataInBenchmarkData.iTotalTime = 0;
			aDevice->iDataInBenchmarkData.iMaxTime = 0;
			aDevice->iDataInBenchmarkData.iMinTime = KMaxTInt;

			aDevice->iDataOutBenchmarkData.iCount = 0;
			aDevice->iDataOutBenchmarkData.iTotalTime = 0;
			aDevice->iDataOutBenchmarkData.iMaxTime = 0;
			aDevice->iDataOutBenchmarkData.iMinTime = KMaxTInt;

			aDevice->iROMBenchmarkData.iCount = 0;
			aDevice->iROMBenchmarkData.iTotalTime = 0;
			aDevice->iROMBenchmarkData.iMaxTime = 0;
			aDevice->iROMBenchmarkData.iMinTime = KMaxTInt;

			aDevice->iCodeBenchmarkData.iCount = 0;
			aDevice->iCodeBenchmarkData.iTotalTime = 0;
			aDevice->iCodeBenchmarkData.iMaxTime = 0;
			aDevice->iCodeBenchmarkData.iMinTime = KMaxTInt;
			break;
		}
	NKern::FMSignal(&aDevice->iInstrumentationLock);
	}
#endif

TInt MediaHalFunction(TAny*, TInt aFunction, TAny* a1, TAny* a2)
	{
	TInt r=KErrNotSupported;
	switch (aFunction)
		{
		case EMediaHalDriveInfo:
			{
			(void) a2;
			TDriveInfoV1Buf infoBuf;
			TDriveInfoV1& info=infoBuf();
			GetDriveInfo(info);
			Kern::InfoCopy(*(TDes8*)a1,infoBuf);
			r=KErrNone;
			break;
			}
#if defined(__DEMAND_PAGING__) && defined(__CONCURRENT_PAGING_INSTRUMENTATION__)
		case EMediaHalGetROMConcurrencyInfo:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ERom);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SMediaROMPagingConcurrencyInfo info=device->iROMStats;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}
		case EMediaHalGetCodeConcurrencyInfo:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ECode);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SMediaCodePagingConcurrencyInfo info=device->iCodeStats;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}
		case EMediaHalGetDataConcurrencyInfo:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::EData);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SMediaDataPagingConcurrencyInfo info=device->iDataStats;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}
		case EMediaHalResetConcurrencyInfo:
			{
			TUint index=(TInt)a2;
			if(index>EMediaPagingStatsCode)
				break;

			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ERom);
			if (device)
				ResetConcurrencyStats(device, (TMediaPagingStats)index);
			device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ECode);
			if (device)
				ResetConcurrencyStats(device, (TMediaPagingStats)index);
			device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::EData);
			if (device)
				ResetConcurrencyStats(device, (TMediaPagingStats)index);

			r=KErrNone;
			break;
			}
#endif
#if defined(__DEMAND_PAGING__) && defined(__DEMAND_PAGING_BENCHMARKS__)
		case EMediaHalGetROMPagingBenchmark:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ERom);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SPagingBenchmarkInfo info = device->iROMBenchmarkData;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}		
		case EMediaHalGetCodePagingBenchmark:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ECode);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SPagingBenchmarkInfo info = device->iCodeBenchmarkData;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}	
		case EMediaHalGetDataInPagingBenchmark:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::EData);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SPagingBenchmarkInfo info = device->iDataInBenchmarkData;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}		
		case EMediaHalGetDataOutPagingBenchmark:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::EData);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SPagingBenchmarkInfo info = device->iDataOutBenchmarkData;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}		
		case EMediaHalResetPagingBenchmark:
			{
			TUint index=(TInt)a2;
			if(index>EMediaPagingStatsCode)
				break;

			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ERom);
			if (device)
				ResetBenchmarkStats(device, (TMediaPagingStats)index);
			device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::ECode);
			if (device)
				ResetBenchmarkStats(device, (TMediaPagingStats)index);
			device = TDriveIterator::PagingDevice((TInt)a1, DPagingDevice::EData);
			if (device)
				ResetBenchmarkStats(device, (TMediaPagingStats)index);

			r=KErrNone;
			break;
			}
		case EMediaHalGetPagingInfo:
			{
			DMediaPagingDevice* device = TDriveIterator::PagingDevice((TInt)a1, (DPagingDevice::TType) 0xFF);
			if(!device)
				break;
			NKern::FMWait(&device->iInstrumentationLock);
			SMediaPagingInfo info = device->iMediaPagingInfo;
			NKern::FMSignal(&device->iInstrumentationLock);
			kumemput32(a2,&info,sizeof(info));
			r=KErrNone;
			break;
			}		
#endif
		default:
			break;
		}
	return r;
	}


/******************************************************************************
 Partition table scanner
 ******************************************************************************/

#ifdef _DEBUG
#define DMEMDUMP(base,size)	DbgMemDump((TLinAddr)base,size)
void DbgMemDump(TLinAddr aBase, TInt aSize)
	{
	TInt off;
	const TUint8* p=(const TUint8*)aBase;
	NKern::Lock();
	for (off=0; off<aSize; off+=16, p+=16)
		{
		Kern::Printf("%04x: %02x %02x %02x %02x  %02x %02x %02x %02x | %02x %02x %02x %02x  %02x %02x %02x %02x",
			off,	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
					p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
		}
	NKern::Unlock();
	}
#else
#define DMEMDUMP(base,size)
#endif

EXPORT_C void TPartitionTableScanner::Set(TUint8* aSectorBuffer, TPartitionEntry* aEntry, TInt aMaxPartitions, TInt64 aMediaSize)
	{
	__KTRACE_OPT(KLOCDRV, Kern::Printf("TPartitionTableScanner @ %08x : buf %08x entry %08x max %d sz %08x %08x",
								this, aSectorBuffer, aEntry, aMaxPartitions, I64HIGH(aMediaSize), I64LOW(aMediaSize)));
	OstTraceExt4( TRACE_INTERNALS, TPARTITIONTABLESCANNER_SET, "TPartitionTableScanner at 0x%08x; aSectorBuffer=0x%08x; aEntry=0x%08x; aMaxPartitions=%d", (TUint) this, (TUint) aSectorBuffer, (TUint) aEntry, aMaxPartitions );
	__ASSERT_ALWAYS(aMaxPartitions>0, LOCM_FAULT());
	memclr(this, sizeof(TPartitionTableScanner));
	iLBA = -1;
	iSectorBuffer = aSectorBuffer;
	iFirstEntry = aEntry;
	iNextEntry = aEntry;
	iLimit = aEntry + aMaxPartitions;
	iMediaSize = aMediaSize;
	}

EXPORT_C TInt TPartitionTableScanner::NumberOfPartitionsFound() const
	{
	TInt n = iNextEntry - iFirstEntry;
	__KTRACE_OPT(KLOCDRV, Kern::Printf("TPartitionTableScanner N=%d", n));
	OstTrace1( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NUMBERPARTITIONS, "Number of partitions=%d", n );
	return n;
	}

TPartitionTableScanner::SPart::SPart(const TUint8* a)
	{
	iBootInd = a[0];
	iType = a[4];
	iRSS = a[8]|(a[9]<<8)|(a[10]<<16)|(a[11]<<24);
	iSectors = a[12]|(a[13]<<8)|(a[14]<<16)|(a[15]<<24);
	__KTRACE_OPT(KLOCDRV, Kern::Printf("SPart: BI=%02x TYPE=%02x RSS=%08x SIZE=%08x", iBootInd, iType, iRSS, iSectors));
	OstTraceExt4(TRACE_INTERNALS, TPARTITIONTABLESCANNER_SPART_SPART, "SPart: iBootInd=%02x; iType=%02x; iRSS=%08x; iSectors=%08x", (TUint) iBootInd, (TUint) iType, (TUint) iRSS, (TUint) iSectors);
	}

TInt TPartitionTableScanner::MakeEntry(const SPart& a)
	{
	OstTraceFunctionEntry1( TPARTITIONTABLESCANNER_MAKEENTRY_ENTRY, this );
	if (iNextEntry == iLimit)
	    {
		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT1, this, KErrOverflow );
		return KErrOverflow;
	    }
	if (a.iRSS<=0 || a.iSectors<=0 || a.iRSS>=iMediaSize)
	    {
		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT2, this, KErrCorrupt );
		return KErrCorrupt;
	    }
	if (TUint64(a.iRSS) + TUint64(a.iSectors) > TUint64(iMediaSize))
	    {
		OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT3, this, KErrCorrupt );
		return KErrCorrupt;
	    }
	iNextEntry->iBootIndicator = a.iBootInd;
	iNextEntry->iPartitionType = a.iType;
	iNextEntry->iPartitionBaseAddr = TInt64(a.iRSS)<<ESectorShift;
	iNextEntry->iPartitionLen = TInt64(a.iSectors)<<ESectorShift;
	++iNextEntry;
	OstTraceFunctionExitExt( TPARTITIONTABLESCANNER_MAKEENTRY_EXIT4, this, KErrNone );
	return KErrNone;
	}

EXPORT_C TInt64 TPartitionTableScanner::NextLBA()
	{
	OstTraceFunctionEntry0( TPARTITIONTABLESCANNER_NEXTLBA_ENTRY );
	__KTRACE_OPT(KLOCDRV, Kern::Printf(">TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA)));
	OstTraceExt2( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA1, "TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA) );
	TInt r;
	TUint8* b = iSectorBuffer;
	TUint8* pS = b + 0x1be;
	TUint8* pE = pS + 64;
	TUint8* p = pS;
	TInt orig_sp = iStackPointer;
	TInt sp;
	if (iLBA < 0)
		{
		iLBA = 0;
		goto end;
		}
	__KTRACE_OPT(KLOCDRV,DMEMDUMP(b, ESectorSize));
	if (b[ESectorSize-2]!=0x55 || b[ESectorSize-1]!=0xaa)
		{
		__KTRACE_OPT(KLOCDRV, Kern::Printf("Bad signature"));
		OstTrace0( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA2, "Bad signature" );
		iLBA = KErrCorrupt;
		goto end;
		}
	if (iLBA==0 && iNextEntry==iFirstEntry)
		{
		// Look for bootable partition first
		for (; p<pE; p+=16)
			{
			SPart pt(p);
			if (pt.iBootInd==0x80 && pt.iType && pt.iSectors>0)
				{
				p[4] = 0;
				r = MakeEntry(pt);
				if (r!=KErrNone)
					{
					iLBA = r;
					goto end;
					}
				}
			}
		}
	// Look for extended partitions
	for (p=pE-16; p>=pS; p-=16)
		{
		SPart pt(p);
		if ((pt.iType==0x05 || pt.iType==0x0f) && pt.iSectors>0)
			{
			// This one is an EBR
			p[4] = 0;
			if (iStackPointer == EMaxNest)
				{
				if (iStackPointer == orig_sp)
					continue;
				--iStackPointer;
				for(sp = orig_sp; sp<iStackPointer; ++sp)
					iStack[sp] = iStack[sp+1];
				}
			iStack[iStackPointer].iRSS = pt.iRSS;
			iStack[iStackPointer].iSectors = pt.iSectors;
			++iStackPointer;
#ifdef _DEBUG
			for (sp=0; sp<iStackPointer; ++sp)
				{
				const TInt64& rss = iStack[sp].iRSS;
				const TInt64& size = iStack[sp].iSectors;
				__KTRACE_OPT(KLOCDRV, Kern::Printf("Stack[%d] RSS %08x %08x SIZE %08x %08x", sp,
					I64HIGH(rss), I64LOW(rss), I64HIGH(size), I64LOW(size) ));
				OstTraceExt5(TRACE_INTERNALS, PARTITIONTABLESCANNER_NEXTLBA3, "Stack[%d] RSS 0x%x 0x%x SIZE 0x%08x 0x%08x", (TInt) sp, (TUint) I64HIGH(rss), (TUint) I64LOW(rss), (TUint) I64HIGH(size), (TUint) I64LOW(size));
				}
#endif
			}
		}
	// Look for other data partitions
	for (p=pS; p<pE; p+=16)
		{
		SPart pt(p);
		if (pt.iType && pt.iSectors>0)
			{
			pt.iRSS += TUint32(iLBA);	// data partitions are specified relative to the EBR they appear in
			r = MakeEntry(pt);
			if (r!=KErrNone)
				{
				iLBA = r;
				goto end;
				}
			}
		}
	// If any EBRs on stack, pop off the first and process it
	if (iStackPointer)
		{
		--iStackPointer;
		iLBA = iFirstEBR + iStack[iStackPointer].iRSS;	// LBA of second and subsequent EBR is specified relative to first EBR
		if (!iFirstEBR)
			iFirstEBR = iLBA;
		}
	else
		iLBA = KErrEof;	// finished

end:
	__KTRACE_OPT(KLOCDRV, Kern::Printf("<TPartitionTableScanner iLBA=%08x %08x", I64HIGH(iLBA), I64LOW(iLBA)));
	OstTraceExt2( TRACE_INTERNALS, TPARTITIONTABLESCANNER_NEXTLBA3, "TPartitionTableScanner iLBA=0x%08x 0x%08x", I64HIGH(iLBA), I64LOW(iLBA) );
	OstTraceFunctionExit0( TPARTITIONTABLESCANNER_NEXTLBA_EXIT );
	return iLBA;
	}

/**
 * Returns Address and Length of next contiguous Physical memory fragment
 * 
 * @param aAddr On success, populated with the Physical Address of the next fragment.
 * @param aLen  On success, populated with the length in bytes of the next fragment.
 * 
 * @return KErrNone, if successful;
 * 		   KErrNoMemory, if no more memory fragments left.
 * 		   KErrNotSupported, if Physical Memory addressing is not supported by this Media.
 */
EXPORT_C TInt TLocDrvRequest::GetNextPhysicalAddress(TPhysAddr& aAddr, TInt& aLen)
	{
	OstTraceExt2(TRACE_FLOW, TLOCDRVREQUEST_GETNEXTPHYSICALADDRESS_ENTRY, "> TLocDrvRequest::GetNextPhysicalAddress;aAddr=%x;aLen=%d;", (TUint) &aAddr, aLen );
	if (Flags() & EPhysAddr) 
		{
#ifdef __DEMAND_PAGING__
		if (DMediaPagingDevice::PagingRequest(*this))
			{
			return DDmaHelper::GetPhysicalAddress(*this, aAddr, aLen);
			}
#endif
		return Drive()->iDmaHelper->GetPhysicalAddress(aAddr, aLen);
		}
	else
		{
		OstTraceFunctionExitExt( TLOCDRVREQUEST_GETNEXTPHYSICALADDRESS_EXIT, this, KErrNotSupported );
		return KErrNotSupported;
		}
	}


/******************************************************************************
 DMediaDriverExtension base class
 ******************************************************************************/

EXPORT_C DMediaDriverExtension::DMediaDriverExtension(TInt aMediaId) :
	DMediaDriver(aMediaId)
	{
	}

/**
*/
EXPORT_C DMediaDriverExtension::~DMediaDriverExtension()
	{
	}

/**
Closes the media driver.

This default implementation simply deletes this DMediaDriverExtension object.

Media drivers can provide their own implementation, which gives them
the opportunity to clean up resources before closure; for example,
cancelling a DFC.
Any replacement function must call this base class function as
the last instruction. 
*/
EXPORT_C void DMediaDriverExtension::Close()
	{
	DMediaDriver::Close();
	}

/**
DoDrivePartitionInfo()

Fills out the passed TPartitionInfo object with information from the attached drives
*/
EXPORT_C TInt DMediaDriverExtension::DoDrivePartitionInfo(TPartitionInfo& aInfo)
	{
	memclr(&aInfo, sizeof(aInfo));
	aInfo.iPartitionCount = 0;
	aInfo.iMediaSizeInBytes = 0;

	TDriveIterator driveIter;
	for (TLocDrv* drv = driveIter.NextDrive(); drv != NULL; drv = driveIter.NextDrive())
		{
		if (drv && drv->iPrimaryMedia == iPrimaryMedia)
			{
			TLocDrv* attachedDrive = drv->iNextDrive;
			__ASSERT_DEBUG(attachedDrive, LOCM_FAULT());
			TLocDrvRequest m;
			memclr(&m, sizeof(m));

			// Get the Caps from the device. NB for MMC/SD we may need to retry as there may have been an earlier 
			// EForceMediaChange request which can result in the cancellation of requests already in the queue
			TBuf8<KMaxLocalDriveCapsLength> capsBuf;
			TInt i;
			const TInt KRetries = 5;
			TInt r = KErrNotReady;
			for (i=0; r == KErrNotReady && i < KRetries; i++)
				{
				capsBuf.SetMax();
				capsBuf.FillZ();
				m.Drive() = attachedDrive;
				m.Id() = DLocalDrive::ECaps;
				m.RemoteDes() = (TAny*)capsBuf.Ptr();
				m.Length() = KMaxLocalDriveCapsLength;
				r = attachedDrive->iPrimaryMedia->Request(m);
				}

			__KTRACE_OPT2(KBOOT,KLOCDPAGING, Kern::Printf("DMediaDriverExtension::PartitionInfo(ECaps: i %d: r %d ", driveIter.Index(), r));
			
			// NB The ECaps call might legitimately fail if one of the attached drives is removable
			// If this happens, just ignore & proceed to the next attached drive
			if (r == KErrNone)
				{
				aInfo.iEntry[aInfo.iPartitionCount] = *attachedDrive;
				// Set the media size to be that of the largest attached media
				// This is only needed to ensure that the test in TLocDrvRequest::CheckAndAdjustForPartition()
				// with the ELocDrvWholeMedia flag set succeeds: A further check on whether a request's
				// position & length are outside the media will be made when its is delievered  to the attached media....
				aInfo.iMediaSizeInBytes = Max(
					aInfo.iMediaSizeInBytes, 
					((TLocalDriveCapsV4*) capsBuf.Ptr())->MediaSizeInBytes());
				}


			aInfo.iPartitionCount++;
			}
		}

	return KErrNone;
	}

/**
ForwardRequest() - 

forwards the request onto the next attached drive in the chain
*/
EXPORT_C TInt DMediaDriverExtension::ForwardRequest(TLocDrvRequest& aRequest)
	{
	TLocDrv* drive = aRequest.Drive();
	TLocDrv* attachedDrive = drive->iNextDrive;
	__ASSERT_DEBUG(attachedDrive, LOCM_FAULT());
	aRequest.Drive() = attachedDrive;


	TInt r = attachedDrive->iPrimaryMedia->HandleMediaNotPresent(aRequest);
	if (r != KErrNone)
		{
		return r;
		}
	
	aRequest.Forward(&attachedDrive->iPrimaryMedia->iMsgQ, EFalse);
	return KErrNone;
	}


TInt DMediaDriverExtension::SendRequest(TInt aReqId, TBool aPagingRequest, TInt aDriveNumber, TInt64 aPos, TLinAddr aData, TUint aLen)
	{
	__ASSERT_DEBUG(aLen > 0, LOCM_FAULT());

	// Ensure this is a legitimate attached drive registered using LocDrv::RegisterMediaDevice()
	if (!(iPrimaryMedia->iBody->iRegisteredDriveMask & (0x1 << aDriveNumber)))
		return KErrArgument;

	TLocDrv* drive = TDriveIterator::GetDrive(aDriveNumber, iPrimaryMedia);
	__ASSERT_DEBUG(drive, LOCM_FAULT());
	TLocDrv* attachedDrive = drive->iNextDrive;
	__ASSERT_DEBUG(attachedDrive, LOCM_FAULT());

	TLocDrvRequest request;
	memclr(&request, sizeof(request));

	request.Drive() = attachedDrive;
	request.Id() = aReqId;
	request.Length() = aLen;
	request.RemoteDes() = (TAny*) aData;
	request.Pos() = aPos;
	request.Flags() = TLocDrvRequest::EKernelBuffer | TLocDrvRequest::EAdjusted;

#ifdef __DEMAND_PAGING__
	if (aPagingRequest)
		{
		request.Flags()|= TLocDrvRequest::EPaging;
		// If the buffer is page aligned, use SendToMainQueueDfcAndBlock() as this 
		// is more efficient if the attached drive use DMA.
		const TInt KPageSizeMask = 4096-1;
		if (aData & KPageSizeMask)
			{
			return attachedDrive->iPrimaryMedia->SendReceive(request, aData);
			}
		else
			{
			attachedDrive->iPrimaryMedia->iBody->iPagingDevice->SendToMainQueueDfcAndBlock(&request);
			return 0;
			}
		}
#else
	aPagingRequest;
#endif

	return attachedDrive->iPrimaryMedia->SendReceive(request, aData);
	}


/**
Read() - 

reads data from the next attached drive in the chain

N.B. The position is assumed to be already adjusted i.e. relative to the start of the
media, not the partition
*/
EXPORT_C TInt DMediaDriverExtension::Read(TInt aDriveNumber, TInt64 aPos, TLinAddr aData, TUint aLen)
	{
	return SendRequest(DLocalDrive::ERead, EFalse, aDriveNumber, aPos, aData, aLen);
	}

/**
Write() - 

writes data to the next attached drive in the chain

N.B. The position is assumed to be already adjusted i.e. relative to the start of the
media, not the partition
*/
EXPORT_C TInt DMediaDriverExtension::Write(TInt aDriveNumber, TInt64 aPos, TLinAddr aData, TUint aLen)
	{
	return SendRequest(DLocalDrive::EWrite, EFalse, aDriveNumber, aPos, aData, aLen);
	}


#ifdef __DEMAND_PAGING__
/**
ReadPaged() - 

Sends a paging read request to the specified attached drive

N.B. The position is assumed to be already adjusted i.e. relative to the start of the
media, not the partition
*/
EXPORT_C TInt DMediaDriverExtension::ReadPaged(TInt aDriveNumber, TInt64 aPos, TLinAddr aData, TUint aLen)
	{
	return SendRequest(DLocalDrive::ERead, ETrue, aDriveNumber, aPos, aData, aLen);
	}

/**
WritePaged() - 

Send a paging write request to the specified attached drive

N.B. The position is assumed to be already adjusted i.e. relative to the start of the
media, not the partition
*/
EXPORT_C TInt DMediaDriverExtension::WritePaged(TInt aDriveNumber, TInt64 aPos, TLinAddr aData, TUint aLen)
	{
	return SendRequest(DLocalDrive::EWrite, ETrue, aDriveNumber, aPos, aData, aLen);
	}
#endif	// __DEMAND_PAGING__



/**
Caps() - 

gets the caps from the next attached drive in the chain

N.B. The position is assumed to be already adjusted i.e. relative to the start of the
media, not the partition
*/
EXPORT_C TInt DMediaDriverExtension::Caps(TInt aDriveNumber, TDes8& aCaps)
	{
	// Ensure this is a legitimate attached drive registered using LocDrv::RegisterMediaDevice()
	if (!(iPrimaryMedia->iBody->iRegisteredDriveMask & (0x1 << aDriveNumber)))
		return KErrArgument;

	TLocDrv* drive = TDriveIterator::GetDrive(aDriveNumber, iPrimaryMedia);
	__ASSERT_DEBUG(drive, LOCM_FAULT());
	TLocDrv* attachedDrive = drive->iNextDrive;
	__ASSERT_DEBUG(attachedDrive, LOCM_FAULT());

	TLocDrvRequest request;
	memclr(&request, sizeof(request));

	request.Drive() = attachedDrive;
	request.Id() = DLocalDrive::ECaps;
	request.Length() = aCaps.Length();
	request.RemoteDes() = (TAny*) aCaps.Ptr();

	return request.SendReceive(&attachedDrive->iPrimaryMedia->iMsgQ);
	}



EXPORT_C void DMediaDriverExtension::NotifyPowerDown()
	{
	}

EXPORT_C void DMediaDriverExtension::NotifyEmergencyPowerDown()
	{
	}


/**
Returns ETrue if this media - or any media which this TLocDrv is attached to - is busy
*/
EXPORT_C TBool DMediaDriverExtension::MediaBusy(TInt aDriveNumber)
	{
	for (TLocDrv* drive = TDriveIterator::GetDrive(aDriveNumber, iPrimaryMedia); 
		drive; 
		drive = drive->iNextDrive)
		{
		DPrimaryMediaBase* primaryMedia = drive->iPrimaryMedia;
		__ASSERT_DEBUG(primaryMedia, LOCM_FAULT());

		if ((primaryMedia->iMsgQ.iMessage && primaryMedia->iMsgQ.iMessage->iState != TMessageBase::EFree) || 
			!primaryMedia->iMsgQ.iQ.IsEmpty() ||
			primaryMedia->iBody->iMediaChangeDfc.Queued() ||
			primaryMedia->iBody->iMediaPresentDfc.Queued())
			return ETrue;

#ifdef __DEMAND_PAGING__
		DMediaPagingDevice* pagingDevice = iPrimaryMedia->iBody->iPagingDevice;
		if (pagingDevice)
			{
			if ((pagingDevice->iMainQ.iMessage && pagingDevice->iMainQ.iMessage->iState != TMessageBase::EFree) || 
				!pagingDevice->iMainQ.iQ.IsEmpty())
			return ETrue;
			}
#endif
		}

	return EFalse;
	}


TCallBackLink::TCallBackLink()
	{
	memclr(this, sizeof(this));
	}

TCallBackLink::TCallBackLink(TInt (*aFunction)(TAny* aPtr, TInt aParam),TAny* aPtr, TObjectType aObjectType) : 
	iFunction(aFunction), iPtr(aPtr), iObjectType(aObjectType)
	{
	}

TInt TCallBackLink::CallBack(TInt aParam) const
	{
	return (*iFunction)(iPtr, aParam);
	}

/******************************************************************************
 Entry point
 ******************************************************************************/
DECLARE_STANDARD_EXTENSION()
	{
	__KTRACE_OPT(KBOOT,Kern::Printf("Starting LOCMEDIA extension"));

	// install the HAL function
	TInt r=Kern::AddHalEntry(EHalGroupMedia,MediaHalFunction,NULL);

#ifdef __DEMAND_PAGING__
	if (r==KErrNone)
		{
		__KTRACE_OPT(KBOOT,Kern::Printf("Creating LocDrv device"));
		DLocalDriveFactory* device = new DLocalDriveFactory;
		if (device==NULL)
			r=KErrNoMemory;
		else
			r=Kern::InstallLogicalDevice(device);
		__KTRACE_OPT(KBOOT,Kern::Printf("Installing LocDrv device in kernel returned %d",r));
		}
#endif // __DEMAND_PAGING__

	return r;
	}


