diff -r 0ffb4e86fcc9 -r a179b74831c9 kerneltest/e32test/mediaext/d_nfe.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/mediaext/d_nfe.cpp	Thu Aug 19 11:14:22 2010 +0300
@@ -0,0 +1,1781 @@
+// Copyright (c) 1995-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:
+// e32test\mediext\d_nfe.cpp
+// 
+//
+
+#include <drivers/locmedia.h>
+#include <platform.h>
+#include <variantmediadef.h>
+#include "nfe.h"
+
+#if defined(_DEBUG)
+//	#define TRACE_ENABLED
+#define TRACE_ENABLED	//*test*
+#else
+#endif
+
+#if defined(TRACE_ENABLED)
+#define __KTRACE_PRINT(p) {p;}
+#else
+#define __KTRACE_PRINT(p)
+#endif
+
+
+
+
+// Variant parameters for test Media Extension Driver
+
+
+const TInt KNfeThreadPriority = 24;	        // same as file server
+const TInt KNfeDiskOpReady = 100;       //100%
+//const TInt KNfeDiskOpStart = 0;         //0%
+
+_LIT(KPddName, "Media.NFE");
+#define NFE_DRIVENAME "NFE"
+#define NFE_NUMMEDIA 1
+
+// Define the array of local drives which we're attaching to
+__ASSERT_COMPILE(sizeof(TNfeDeviceInfo) <= 256);	// KMaxQueryDeviceLength
+
+// Define the array of local code-paging drives which we're attaching to
+#ifdef __DEMAND_PAGING__
+	__ASSERT_COMPILE(NFE_PAGEDRIVECOUNT <= TNfeDeviceInfo::ENfeMaxPartitionEntries);
+	__ASSERT_COMPILE(NFE_DRIVECOUNT >= NFE_PAGEDRIVECOUNT);
+	#define	SECTOR_SHIFT 9
+#endif	// #ifdef __DEMAND_PAGING__
+
+
+
+
+class DPrimaryMediaExt : public DPrimaryMediaBase
+	{
+public:
+	DPrimaryMediaExt(TInt aInstance);
+public:
+	TInt iInstance;
+	TDfcQue iNfeDfcQ;
+	};
+
+
+
+// Get the number of drives in the drive array belonging to this instance 
+TInt DriveCount(TInt aInstance)
+	{
+	static const TInt NfeInstanceDriveCounts[NFE_INSTANCE_COUNT]={NFE_INSTANCE_DRIVE_COUNTS};
+	return NfeInstanceDriveCounts[aInstance];
+	}
+
+// Get a pointer to the first drive in the drive array belonging to this instance 
+const TInt* DriveList(TInt aInstance)
+	{
+	static const TInt NfeDriveNumbers[NFE_DRIVECOUNT]={NFE_DRIVELIST};
+	TInt driveListOffset = 0;
+	for (TInt n=0; n<aInstance; n++)
+		driveListOffset+= DriveCount(n);
+	return  NfeDriveNumbers + driveListOffset;
+	}
+
+const TInt* DriveLetterList(TInt aInstance)
+	{
+	static const TInt NfeDriveLetters[NFE_DRIVECOUNT]={NFE_DRIVELETTERLIST};
+	TInt driveListOffset = 0;
+	for (TInt n=0; n<aInstance; n++)
+		driveListOffset+= DriveCount(n);
+	return  NfeDriveLetters + driveListOffset;
+	}
+
+TInt DriveLetter(TInt aIndex)
+	{
+	static const TInt NfeDriveLetters[NFE_DRIVECOUNT]={NFE_DRIVELETTERLIST};
+	return NfeDriveLetters[aIndex];
+	}
+
+TChar DriveLetterToAscii(TInt aDriveLetter)
+	{
+	return aDriveLetter >= 0 && aDriveLetter <= 25 ? aDriveLetter +'A' : '?';
+	}
+
+#ifdef __DEMAND_PAGING__
+	// Get the number of drives in the paged drive array belonging to this instance 
+	TInt PageDriveCount(TInt aInstance)
+		{
+	#if NFE_PAGEDRIVECOUNT > 0
+		static const TInt NfeInstancePageDriveCounts[NFE_INSTANCE_COUNT]={NFE_INSTANCE_PAGEDRIVE_COUNTS};
+		return NfeInstancePageDriveCounts[aInstance];
+	#else
+		return 0;
+	#endif
+		}
+
+	// Get a pointer to the first drive in the paged drive array belonging to this instance 
+	const TInt* PageDriveList(TInt aInstance)
+		{
+	#if NFE_PAGEDRIVECOUNT > 0
+		static const TInt NfePageDriveNumbers[NFE_PAGEDRIVECOUNT]={NFE_PAGEDRIVELIST};
+		TInt driveListOffset = 0;
+		for (TInt n=0; n<aInstance; n++)
+			driveListOffset+= PageDriveCount(n);
+		return  NfePageDriveNumbers + driveListOffset;
+	#else
+		return NULL;
+	#endif
+		}
+
+	// Get the number of paging type belonging to this instance 
+	TInt PagingType(TInt aInstance)
+		{
+	#if NFE_PAGEDRIVECOUNT > 0
+		static const TInt NfeInstancePagingType[NFE_INSTANCE_COUNT]={NFE_INSTANCE_PAGING_TYPE};
+		return NfeInstancePagingType[aInstance];
+	#else
+		return 0;
+	#endif
+		}
+
+	// get the instance of the swap drive
+	TInt SwapInstance()
+		{
+		for (TInt i=0; i<NFE_INSTANCE_COUNT; i++)
+			if (PagingType(i) & DPagingDevice::EData)
+				return i;
+		return KErrNotFound;
+		}
+#endif	// #ifdef __DEMAND_PAGING__
+
+
+const char* DriveStatus(TNfeDiskStatus aStatus)
+	{
+	const char* KNfeUnmounted = "Unmounted";
+	const char* KNfeDecrypted = "Decrypted";
+	const char* KNfeDecrypting = "Decrypting";
+	const char* KNfeEncrypted = "Encrypted";
+	const char* KNfeEncrypting = "Encrypting";
+	const char* KNfeWiping = "Wiping";
+	const char* KNfeCorrupted = "Corrupted";
+	const char* KNfeUnrecognised = "Unrecognised";
+
+	switch(aStatus)
+		{
+		case ENfeUnmounted:
+			return KNfeUnmounted;
+		case ENfeDecrypted:
+			return KNfeDecrypted;
+		case ENfeDecrypting:
+			return KNfeDecrypting;
+		case ENfeEncrypted:
+			return KNfeEncrypted;
+		case ENfeEncrypting:
+			return KNfeEncrypting;
+		case ENfeWiping:
+			return KNfeWiping;
+		case ENfeCorrupted:
+			return KNfeCorrupted;
+		default:
+			return KNfeUnrecognised;
+
+		}
+	}
+
+
+DPrimaryMediaExt::DPrimaryMediaExt(TInt aInstance) : iInstance(aInstance)
+	{
+	}
+
+
+#define NFE_FAULT()	Kern::Fault("NFEMEDIA",__LINE__)
+
+// disk encryption/decryption/wiping is only performed after the following period of inactivity
+// NB USB Mass Storage tends to 'poll' the media driver by sending ECaps every second or so, so we need
+// to ensure this timeout period is significantly less to ensure the timer DFC thread gets a chance to run...
+const TInt KNotBusyInterval = 200;		// 200 mS
+
+
+
+class DPhysicalDeviceMediaNFE : public DPhysicalDevice
+	{
+public:
+	DPhysicalDeviceMediaNFE();
+	virtual TInt Install();
+	virtual void GetCaps(TDes8& aDes) const;
+	virtual TInt Create(DBase*& aChannel, TInt aMediaId, const TDesC8* anInfo, const TVersion& aVer);
+	virtual TInt Validate(TInt aDeviceType, const TDesC8* anInfo, const TVersion& aVer);
+	virtual TInt Info(TInt aFunction, TAny* a1);
+	};
+								
+
+class DMediaDriverNFE : public DMediaDriverExtension
+	{
+public:
+	class TPropertyObserver
+		{
+	public:
+		void Close();
+		static void PropertySubsCompleteFn(TAny* aPtr, TInt aReason);
+	public:
+		TInt iDriveIndex;
+		DMediaDriverNFE* iMediaExt;
+		RPropertyRef iProperty;
+		TPropertySubsRequest* iPropertySubsRequest;
+		TDfc* iPropertyDfc;	// N.B. subscription call backs don't occur in our thread context, hence the need for this DFC
+		TInt iValue;
+		};
+
+public:
+	 DMediaDriverNFE(TInt aMediaId);
+	~DMediaDriverNFE();
+
+	// replacing pure virtual
+	virtual TInt Request(TLocDrvRequest& aRequest);
+	virtual TInt PartitionInfo(TPartitionInfo &anInfo);
+
+	TInt DoCreate(TInt aMediaId);
+	void Close();
+
+	TNfeDriveInfo*  GetSwapDrive();
+
+private:
+	TInt HandleRead(TLocDrvRequest& aRequest);
+	TInt HandleWrite(TLocDrvRequest& aRequest);
+	TInt HandleFormat(TLocDrvRequest& aRequest);
+	TInt HandleCaps(TLocDrvRequest& aReq);
+
+
+	void EncryptBuffer(TDes8& aBuffer);
+	void DecryptBuffer(TDes8& aBuffer);
+
+	inline TUint8 EncryptByte(TUint8 aByte) {return (TUint8) (aByte ^ 0xDD);}
+	inline TUint8 DecryptByte(TUint8 aByte) {return (TUint8) (aByte ^ 0xDD);}
+	inline TInt DriveIndex(TInt aDriveNum) {return iDriveNumToIndex[aDriveNum];}
+
+	static void IdleTimerCallBack(TAny* aMediaDriver);
+	static void TimerDfcFunction(TAny* aMediaDriver);
+
+	// Publish & Subscribe stuff - used to listen to requests from UI 
+	static void FromUiPropertyDfcFunction(TAny* aObserver);
+	void FromUiPropertyDfc(TPropertyObserver& aObserver);
+
+	// Publish & Subscribe stuff - used to listen to status setting from other NFE drives
+	static void StatusToUiPropertyDfcFunction(TAny* aObserver);
+	void StatusToUiPropertyDfc(TPropertyObserver& aObserver);
+
+	void StartEncrypting();
+	void StartDecrypting();
+
+	TInt HandleDiskContent();	// called from idle timer DFC
+
+	TNfeDriveInfo* NextDrive();
+	
+	TBool AdjustRequest(TNfeDriveInfo*& aDriveInfo, TInt64& aCurrentPos, TInt64& aCurrentLen);
+
+	void SetStatus(TNfeDriveInfo& aDi, TNfeDiskStatus aStatus);
+
+	TBool ValidBootSector(TUint8* aBuffer);
+	TUint32 VolumeId(TUint8* aBuffer);
+	void CheckBootSector(TNfeDriveInfo &aDriveInfo);
+	TInt WriteEncryptionStatusToBootSector(TNfeDriveInfo &aDi, TBool aFinalised = EFalse);
+
+private:
+	TInt iInstance;		// media drive instance
+
+	// A local buffer use for encryting / decrypting
+	// For paging requests we need this to be page aligned, so allocate enough to cater for 
+	// the worst case of up to 4K being wasted at the start of the buffer and the end
+	enum {KSectorSize = 512, KPageSize = 4096, KBufSize = 65536};
+	TUint8 iNonPageAlignedBuffer[KBufSize + KPageSize*2];
+	// a pointer to the start of the first page in iNonPageAlignedBuffer
+	TUint8* iBuffer;
+
+	
+	// Idle timer & DFC for kicking an encryption pass
+	NTimer iIdleTimer;
+	TDfc iTimerDfc;
+
+	TInt iDriveIndex;								// index of local drive number currently being encrypted
+	TInt iDriveNumToIndex[KMaxPartitionEntries];	// maps drive numbers to index
+
+	TBool iBusy;
+
+	const TInt* iDriveList;	// pointer into the drives in NFE_DRIVELIST belonging to this media driver
+	const TInt* iDriveLetterList;	// pointer into the drive letter in NFE_DRIVELETTERLIST belonging to this media driver
+
+	// Publish & subscribe stuff which handles drive command notification events from the UI
+	TPropertyObserver iFromUiPropertyObserver[NFE_DRIVECOUNT];
+
+	// Publish & subscribe stuff which handles drive status notification events from the other NFE drives
+	TPropertyObserver iStatusToUiPropertyObserver[NFE_DRIVECOUNT];
+
+	TBool iDriveFinalised;
+
+public:
+	// Partition information etc for drives this driver is attached to
+	TNfeDeviceInfo iInfo;
+	};
+
+
+
+class TBootSectorStatus
+	{
+public:
+	TUint8 iFatBootSectorData[128];
+	
+	enum {ENfeBootSectorSignature = 0x2045464E};	// 'NFE '
+	TUint32 iSignature;
+
+	TNfeDiskStatus iStatus;
+	TBool iFinalised;
+	TInt64 iEncryptEndPos;	// position of the last encrypted byte +1. Only written when device is powered down
+	};
+
+
+DPhysicalDeviceMediaNFE::DPhysicalDeviceMediaNFE()
+	{
+	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::DPhysicalDeviceMediaNFE()"));
+	iUnitsMask=0x1;
+	iVersion=TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
+	}
+
+/**
+Install the Internal NFE PDD.
+*/
+TInt DPhysicalDeviceMediaNFE::Install()
+	{
+	__KTRACE_PRINT(Kern::Printf(": TInt DPhysicalDeviceMediaNFE::Install()"));
+
+	return SetName(&KPddName);
+	}
+
+void DPhysicalDeviceMediaNFE::GetCaps(TDes8& /*aDes*/) const
+	{
+	}
+
+/**
+Create an NFE media driver.
+*/
+TInt DPhysicalDeviceMediaNFE::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /* anInfo */,const TVersion &aVer)
+	{
+	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::Create()"));
+
+	if (!Kern::QueryVersionSupported(iVersion,aVer))
+		return KErrNotSupported;
+
+	TInt r=KErrNoMemory;
+
+	DMediaDriverNFE* pD = new DMediaDriverNFE(aMediaId);
+	aChannel=pD;
+	if (pD)
+		r=pD->DoCreate(aMediaId);
+
+	if (r == KErrNone)
+		pD->OpenMediaDriverComplete(KErrNone);
+
+	return r;
+	}
+
+TInt DPhysicalDeviceMediaNFE::Validate(TInt aDeviceType, const TDesC8* /*anInfo*/, const TVersion& aVer)
+	{
+	TInt r;
+	if (!Kern::QueryVersionSupported(iVersion,aVer))
+		r = KErrNotSupported;
+	else if (aDeviceType == MEDIA_DEVICE_NFE)
+		return r = KErrNone;
+	else
+		r = KErrNotSupported;
+
+//	__KTRACE_PRINT(Kern::Printf("DPhysicalDeviceMediaNFE::Validate() aDeviceType %d NfeDeviceType %d r %d", aDeviceType, MEDIA_DEVICE_NFE, r));
+	return r;
+	}
+
+TInt DPhysicalDeviceMediaNFE::Info(TInt aFunction, TAny*)
+//
+// Return the priority of this media driver
+//
+	{
+//	__KTRACE_PRINT(Kern::Printf(": DPhysicalDeviceMediaNFE::Info()"));
+
+	if (aFunction==EPriority)
+		return KMediaDriverPriorityNormal;
+
+	if (aFunction==EMediaDriverPersistent)
+		return KErrNone;
+
+	return KErrNotSupported;
+	}
+
+DMediaDriverNFE::DMediaDriverNFE(TInt aMediaId) :
+	DMediaDriverExtension(aMediaId),
+	iInstance(((DPrimaryMediaExt*) iPrimaryMedia)->iInstance),
+	iIdleTimer(IdleTimerCallBack,this),
+	iTimerDfc(TimerDfcFunction,this,2),
+	iDriveList (DriveList(iInstance)),
+	iDriveLetterList (DriveLetterList(iInstance))
+	{
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::DMediaDriverNFE()", iInstance));
+	iInfo.iDriveCount = DriveCount(iInstance);
+
+	__ASSERT_ALWAYS(Kern::RoundToPageSize(1) == KPageSize, NFE_FAULT());
+
+	// Align the buffer to a page boundary to improve efficiency for paging requests
+	iBuffer = &iNonPageAlignedBuffer[0];
+	iBuffer = (TUint8*) ((((TUint32) &iNonPageAlignedBuffer[0]) + KPageSize-1) & ~(KPageSize-1));
+	}
+
+DMediaDriverNFE::~DMediaDriverNFE()
+//
+// Destructor.
+//
+	{
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::~DMediaDriverNFE()", iInstance));
+
+	TInt i;
+	for (i=0; i<TNfeDeviceInfo::ENfeMaxPartitionEntries; i++)
+		{
+		RPropertyRef* property = (RPropertyRef*) iInfo.iDrives[i].iStatusToUiProperty;
+		if (property)
+			{
+			property->Delete();
+			delete property;
+			}
+		property = (RPropertyRef*) iInfo.iDrives[i].iToUiProperty;
+		if (property)
+			{
+			property->Delete();
+			delete property;
+			}
+		property = (RPropertyRef*) iInfo.iDrives[i].iProgressToUiProperty;
+		if (property)
+			{
+			property->Delete();
+			delete property;
+			}
+		}
+
+	for (i=0; i<NFE_DRIVECOUNT; i++)
+		{
+		iFromUiPropertyObserver[i].Close();
+		iStatusToUiPropertyObserver[i].Close();
+		}
+	}
+
+
+TInt CreateKey(RPropertyRef*& aProperty, TUint aKey)
+	{
+	aProperty = new RPropertyRef;
+	if (aProperty == NULL)
+		return KErrNoMemory;
+	TInt r = aProperty->Attach(KNfeUID, aKey);
+	if (r != KErrNone)
+		return r;
+
+    static _LIT_SECURITY_POLICY_PASS(KPassPolicy);
+	r = aProperty->Define( RProperty::EInt, KPassPolicy, KPassPolicy );
+	if (r != KErrNone && r != KErrAlreadyExists)
+		return r;
+	return KErrNone;
+	}
+
+TInt DMediaDriverNFE::DoCreate(TInt /*aMediaId*/)
+//
+// Create the media driver.
+//
+	{
+	__KTRACE_PRINT(Kern::Printf("NFE%d: TInt DMediaDriverNFE::DoCreate()", iInstance));
+
+	// Associate the idle timer DFC with our thread
+	iTimerDfc.SetDfcQ(iPrimaryMedia->iDfcQ);
+
+	// Publish & Subscribe stuff - used to initiate an encryption pass from the test app
+	static _LIT_SECURITY_POLICY_PASS(KPassPolicy);
+	TInt r;
+	TInt i;
+
+	TInt swapInstance = KErrNotFound;
+#if defined (__DEMAND_PAGING__)
+	swapInstance = SwapInstance();
+#endif
+
+	// **************************************************************************************
+	// Set up P&S publishers so we can publish the status for our drives
+	// **************************************************************************************
+	__KTRACE_PRINT(Kern::Printf("NFE%d: Setting up StatusToUi, ToUi, ProgressToUi P&S publisher & FromUi P&S observer", iInstance));
+
+	for (i = 0; i<DriveCount(iInstance); i++)
+		{
+		__KTRACE_PRINT(Kern::Printf("NFE%d:drive index %d", iInstance, i));
+		TInt driveLetter = iDriveLetterList[i];
+		__KTRACE_PRINT(Kern::Printf("NFE%d:drive letter %c", iInstance, (TInt) DriveLetterToAscii(driveLetter)));
+
+		// no point setting up P&S for the swap drive
+		if (driveLetter == -1)
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: i %d, Skipping P&S for swap partition", iInstance, i));
+			continue;
+			}
+
+		r = CreateKey((RPropertyRef*&) iInfo.iDrives[i].iStatusToUiProperty, NFE_KEY(driveLetter, KNfeStatusToUiKey));
+		if (r != KErrNone)
+			return r;
+
+		r = CreateKey((RPropertyRef*&) iInfo.iDrives[i].iToUiProperty, NFE_KEY(driveLetter, KNfeToUiKey));
+		if (r != KErrNone)
+			return r;
+
+		r = CreateKey((RPropertyRef*&) iInfo.iDrives[i].iProgressToUiProperty, NFE_KEY(driveLetter, KNfeProgressToUiKey));
+		if (r != KErrNone)
+			return r;
+
+		TPropertyObserver& observer = iFromUiPropertyObserver[i];
+		observer.iDriveIndex = i;
+		observer.iMediaExt = this;
+		observer.iPropertySubsRequest = new TPropertySubsRequest(TPropertyObserver::PropertySubsCompleteFn, &observer);
+		if (observer.iPropertySubsRequest == NULL)
+			return KErrNoMemory;
+
+		observer.iPropertyDfc = new TDfc(FromUiPropertyDfcFunction,&observer,iPrimaryMedia->iDfcQ,2);
+		if (observer.iPropertyDfc == NULL)
+			return KErrNoMemory;
+		
+		r = observer.iProperty.Attach(KNfeUID, NFE_KEY(driveLetter, KNfeToThreadKey));
+		if (r != KErrNone)
+			return r;
+		r = observer.iProperty.Define(
+			RProperty::EInt,
+			KPassPolicy, 
+			KPassPolicy);
+		if (r != KErrNone && r != KErrAlreadyExists)
+			return r;
+
+		r = observer.iProperty.Subscribe(*observer.iPropertySubsRequest);
+		if (r != KErrNone)
+			return r;
+		}
+
+	// **************************************************************************************
+	// If this instance owns the swap partition,
+	// set up P&S listeners so we can get status notification events from the other drives
+	// **************************************************************************************
+	__KTRACE_PRINT(Kern::Printf("NFE%d: Setting up StatusToUi P&S observer", iInstance));
+
+	for (i = 0; i < (iInstance == swapInstance ? NFE_DRIVECOUNT : -1); i++)
+		{
+		__KTRACE_PRINT(Kern::Printf("NFE%d:drive index %d", iInstance, i));
+		__KTRACE_PRINT(Kern::Printf("NFE%d:drive letter %c", iInstance, (TInt) DriveLetterToAscii(DriveLetter(i))));
+
+		// no point setting up P&S for the swap drive
+		if (DriveLetter(i) == -1)
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: i %d, Skipping StatusToUi P&S observer for swap partition", iInstance, i));
+			continue;
+			}
+
+		__KTRACE_PRINT(Kern::Printf("NFE%d: i %d, Setting up StatusToUi P&S observer for drive %c", iInstance, i, (TInt) DriveLetterToAscii(DriveLetter(i))));
+		TPropertyObserver& observer = iStatusToUiPropertyObserver[i];
+		observer.iDriveIndex = i;
+		observer.iMediaExt = this;
+		observer.iPropertySubsRequest = new TPropertySubsRequest(TPropertyObserver::PropertySubsCompleteFn, &observer);
+		if (observer.iPropertySubsRequest == NULL)
+			return KErrNoMemory;
+
+		observer.iPropertyDfc = new TDfc(StatusToUiPropertyDfcFunction,&observer,iPrimaryMedia->iDfcQ,2);
+		if (observer.iPropertyDfc == NULL)
+			return KErrNoMemory;
+		
+		r = observer.iProperty.Attach(KNfeUID, NFE_KEY(DriveLetter(i), KNfeStatusToUiKey));
+		if (r != KErrNone)
+			return r;
+		r = observer.iProperty.Define(
+			RProperty::EInt,
+			KPassPolicy, 
+			KPassPolicy);
+		if (r != KErrNone && r != KErrAlreadyExists)
+			return r;
+
+		r = observer.iProperty.Subscribe(*observer.iPropertySubsRequest);
+		if (r != KErrNone)
+			return r;
+		}
+
+	return(KErrNone);
+	}
+
+void DMediaDriverNFE::TPropertyObserver::Close()
+	{
+	iProperty.Close();
+	delete iPropertyDfc;
+	iPropertyDfc = NULL;
+	delete iPropertySubsRequest;
+	iPropertySubsRequest = NULL;
+	}
+
+void DMediaDriverNFE::TPropertyObserver::PropertySubsCompleteFn(TAny* aPtr, TInt /*aReason*/)
+	{
+	TPropertyObserver* self = (TPropertyObserver*) aPtr;
+	// Queue a DFC to ensure we're running in the correct thread
+	self->iPropertyDfc->Enque();
+	}
+
+void DMediaDriverNFE::FromUiPropertyDfcFunction(TAny* aObserver)
+	{
+	TPropertyObserver& observer = *(TPropertyObserver*) aObserver;
+	observer.iMediaExt->FromUiPropertyDfc(observer);
+	}
+
+void DMediaDriverNFE::FromUiPropertyDfc(TPropertyObserver& aObserver)
+	{
+    // Get the value of request from the UI
+    TInt err = aObserver.iProperty.Get(aObserver.iValue);
+
+	TInt r = aObserver.iProperty.Subscribe(*aObserver.iPropertySubsRequest);
+	__ASSERT_ALWAYS(r == KErrNone, NFE_FAULT());
+
+	TInt driveLetter = iDriveLetterList[aObserver.iDriveIndex];
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::FromUiPropertyDfc() cmd %d driveLetter %c", 
+		iInstance, aObserver.iValue, (TInt) DriveLetterToAscii(driveLetter)));
+
+	// is this our drive letter ?
+	TInt driveCount = DriveCount(iInstance);
+	TNfeDriveInfo* driveInfo = NULL;
+
+	for (TInt i=0; i<driveCount; i++)
+		{
+		TInt myDriveLetter = iDriveLetterList[i];
+
+		__KTRACE_PRINT(Kern::Printf("NFE%d: Comparing drive %c with myDrive %c", iInstance, (TInt) DriveLetterToAscii(driveLetter), (TInt) DriveLetterToAscii(myDriveLetter)));
+
+		if (myDriveLetter == driveLetter)
+			{
+			TInt driveNumber = iDriveList[i];
+			driveInfo = &iInfo.iDrives[iDriveNumToIndex[driveNumber]];
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Drive Match found driveNumber %d", iInstance, driveInfo->iLocalDriveNum));
+
+			__ASSERT_ALWAYS(driveInfo->iProgressToUiProperty, NFE_FAULT());
+			((RPropertyRef*) (driveInfo->iProgressToUiProperty))->Set(0); 
+			// Wake up the possibly waiting client, whether or not the request
+			// was successfull.
+			((RPropertyRef*) (driveInfo->iToUiProperty))->Set( err ); // Return value ignored
+			break;
+			}
+		}
+
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: err %d aObserver.iValue %d swap %x swap state %d", iInstance, err, aObserver.iValue, GetSwapDrive(), GetSwapDrive() ? GetSwapDrive()->Status() : -1));
+
+	if (err == KErrNone && aObserver.iValue == ENfeEncryptDisk && driveInfo != NULL)
+		{
+		if (driveInfo->Status() == ENfeDecrypted)
+			{
+			SetStatus(*driveInfo, ENfeEncrypting);
+			StartEncrypting();
+			}
+		}
+	if (err == KErrNone && aObserver.iValue == ENfeDecryptDisk && driveInfo != NULL)
+		{
+		if (driveInfo->Status() == ENfeEncrypted)
+			{
+			SetStatus(*driveInfo, ENfeDecrypting);
+			StartDecrypting();
+			}
+		}
+	}
+
+
+void DMediaDriverNFE::StatusToUiPropertyDfcFunction(TAny* aObserver)
+	{
+	TPropertyObserver& observer = *(TPropertyObserver*) aObserver;
+	observer.iMediaExt->StatusToUiPropertyDfc(observer);
+	}
+
+void DMediaDriverNFE::StatusToUiPropertyDfc(TPropertyObserver& aObserver)
+	{
+    // Get the value of request from the UI
+    TInt err = aObserver.iProperty.Get(aObserver.iValue);
+
+	TInt r = aObserver.iProperty.Subscribe(*aObserver.iPropertySubsRequest);
+	__ASSERT_ALWAYS(r == KErrNone, NFE_FAULT());
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::StatusToUiPropertyDfc() status %d driveLetter %c", 
+		iInstance, aObserver.iValue, DriveLetter(aObserver.iDriveIndex) >=0 ? DriveLetter(aObserver.iDriveIndex)+'A' : '?'));
+
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: err %d aObserver.iValue %d swap %x swap state %d", iInstance, err, aObserver.iValue, GetSwapDrive(), GetSwapDrive() ? GetSwapDrive()->Status() : -1));
+
+	if (err == KErrNone && (aObserver.iValue == ENfeEncrypted || aObserver.iValue == ENfeEncrypting))
+		{
+		// If any drive is being or is already encrypted then we have to encrypt the swap partition...
+		TNfeDriveInfo* diSwap = GetSwapDrive();
+		if (diSwap != NULL && diSwap->Status() == ENfeDecrypted)
+			{
+			SetStatus(*diSwap, ENfeEncrypting);
+			StartEncrypting();
+			}
+		}
+	}
+
+
+void DMediaDriverNFE::Close()
+	{
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::Close()", iInstance));
+	DMediaDriverExtension::Close();
+	}
+
+
+void DMediaDriverNFE::SetStatus(TNfeDriveInfo& aDi, TNfeDiskStatus aStatus)
+	{
+	if (aStatus != aDi.Status())
+		{
+		aDi.SetStatus(aStatus);
+		__KTRACE_PRINT(Kern::Printf("NFE%d: SetStatus = %s", iInstance, DriveStatus(aDi.Status())));
+		}
+	}
+
+void TNfeDriveInfo::SetStatus(TNfeDiskStatus aStatus)
+    {
+	iStatus = aStatus;
+	if (IsUDADrive())
+		{
+		// Update the status pub&sub variable for UI
+		__ASSERT_ALWAYS(iStatusToUiProperty, NFE_FAULT());
+		((RPropertyRef*) iStatusToUiProperty)->Set(aStatus);
+		}
+	}
+
+
+
+
+TInt DMediaDriverNFE::Request(TLocDrvRequest& aReq)
+	{
+//	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::DoRequest() : Req %d drv %d flags %x pos %lx len %lx", iInstance, reqId, aReq.Drive()->iDriveNumber, aReq.Flags(), aReq.Pos(), aReq.Length()));
+
+	TInt r = KErrNotSupported;
+
+	TInt reqId = aReq.Id();
+    TNfeDriveInfo& di = iInfo.iDrives[DriveIndex(aReq.Drive()->iDriveNumber)];
+
+	switch (reqId)
+		{
+#if defined(__DEMAND_PAGING__)
+		case DMediaPagingDevice::ERomPageInRequest:
+			BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaPagingMedDrvBegin,MEDIA_DEVICE_NFE,&aReq);
+			r=HandleRead(aReq);
+			break;
+
+		case DMediaPagingDevice::ECodePageInRequest:
+			BTraceContext8(BTrace::EPagingMedia,BTrace::EPagingMediaPagingMedDrvBegin,MEDIA_DEVICE_NFE,&aReq);
+			r=HandleRead(aReq);
+			break;
+
+#endif	// __DEMAND_PAGING__
+
+		case DLocalDrive::ERead:
+			r=HandleRead(aReq);
+			break;
+
+		case DLocalDrive::EWrite:
+			r=HandleWrite(aReq);
+			break;
+
+		case DLocalDrive::ECaps:
+			r = HandleCaps(aReq);
+			break;
+
+		case DLocalDrive::EFormat:
+			r = HandleFormat(aReq);
+			break;
+
+		// API used by T_NFE to query state etc.
+		case DLocalDrive::EQueryDevice:
+			switch((TInt) aReq.iArg[0])
+				{
+				case EQueryNfeDeviceInfo:
+					{
+					TNfeDeviceInfo& deviceInfo = *(TNfeDeviceInfo*) aReq.RemoteDes();
+					iInfo.iMediaSizeInBytes = iTotalSizeInBytes;
+					deviceInfo = iInfo;
+
+					r = KErrCompletion;
+					break;
+					}
+				case RLocalDrive::EQueryFinaliseDrive:
+					{
+//					TLocalDriveFinaliseInfo& finaliseInfo = *(TLocalDriveFinaliseInfo*) aReq.RemoteDes();
+//					__KTRACE_PRINT(Kern::Printf("NFE%d: EQueryFinaliseDrive iMode %d", iInstance, finaliseInfo.iMode));
+
+					// write to boot sector to indicate that the drive has ben finalised
+					WriteEncryptionStatusToBootSector(di, ETrue);
+					}
+				default:
+					r = KErrNotSupported;
+					break;
+				}
+			break;
+
+		default:
+			r = ForwardRequest(aReq);
+			break;
+		}
+
+//	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::DoRequest() : ret: %d", iInstance, r));
+
+	if (!di.iDriveFinalised && iBusy)
+		{
+		// Restart the idle timer after processing a request 
+		iIdleTimer.Cancel();
+		iTimerDfc.Cancel();
+		iIdleTimer.OneShot(NKern::TimerTicks(KNotBusyInterval));
+		}
+
+	return r;
+	}
+
+/**
+PartitionInfo()
+
+    Reads the partition information from the attached drive(s). 
+    Note: this method is also called when a removable card is removed, so can  
+    be used to detect a memory card insertions/removals. Assumes the swap 
+    partition is encrypted if any encrypted FAT drives are found
+*/
+TInt DMediaDriverNFE::PartitionInfo(TPartitionInfo& aInfo)
+	{
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DMediaDriverNFE::PartitionInfo()", iInstance));
+
+	TInt r = DoDrivePartitionInfo(aInfo);
+	__KTRACE_PRINT(Kern::Printf("NFE%d: DoDrivePartitionInfo() r %d", iInstance, r));
+	if (r != KErrNone)
+		return r;
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: *** Slave drives partition info ***", iInstance));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: iMediaSizeInBytes %lx", iInstance, aInfo.iMediaSizeInBytes));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: iPartitionCount %d", iInstance, aInfo.iPartitionCount));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: ", iInstance));
+
+	TInt i;
+
+	__ASSERT_DEBUG(aInfo.iPartitionCount <= TNfeDeviceInfo::ENfeMaxPartitionEntries, NFE_FAULT());
+	for (i=0; i<aInfo.iPartitionCount; i++)
+		{
+		TInt driveNum = iDriveList[i];
+		iDriveNumToIndex[driveNum] = i;
+
+		TNfeDriveInfo& di = iInfo.iDrives[i];
+
+		di.iDriveFinalised = EFalse;	// a remount clears the finalised state
+
+		// Make sure we haven't lost the swap partition
+		__ASSERT_ALWAYS(!(di.iEntry.iPartitionType == KPartitionTypePagedData && aInfo.iEntry[i].iPartitionType != KPartitionTypePagedData), NFE_FAULT());
+
+		// Make a copy of the TPartitionEntry
+		di.iEntry = aInfo.iEntry[i];
+
+
+		// save the local drive number
+		di.iLocalDriveNum = driveNum;
+		di.iDriveLetter = iDriveLetterList[i];
+
+		__KTRACE_PRINT(Kern::Printf("NFE%d: DriveNum %d", iInstance, driveNum));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: DriveLetter %c", iInstance, (TInt) DriveLetterToAscii(di.iDriveLetter)));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: iPartitionBaseAddr %lX", iInstance, di.iEntry.iPartitionBaseAddr));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: iPartitionLen %lx", iInstance, di.iEntry.iPartitionLen));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: iPartitionType %x", iInstance, di.iEntry.iPartitionType));
+		
+
+		// If the drive was removed, reset it's state
+		if (di.iEntry.iPartitionType == KPartitionTypeEmpty)
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Empty Partition, setting state to ENfeUnmounted", iInstance));
+			SetStatus(di, ENfeUnmounted);
+			}
+
+		// Is this an unencrypted FAT partition ?
+		if (di.IsUDADrive())
+			{
+			r = Read(di.iLocalDriveNum, di.iEntry.iPartitionBaseAddr, (TLinAddr) iBuffer, KSectorSize);
+			if (r != KErrNone)
+				return r;
+			CheckBootSector(di);
+			}
+		
+
+		__KTRACE_PRINT(Kern::Printf("NFE%d: status = %s", iInstance, DriveStatus(di.Status())));
+
+		__KTRACE_PRINT(Kern::Printf("NFE%d: iEncryptStartPos %lX", iInstance, di.iEncryptStartPos));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: iEncryptEndPos %lX", iInstance, di.iEncryptEndPos));
+		__KTRACE_PRINT(Kern::Printf("NFE%d: ", iInstance));
+		}
+
+
+
+#ifdef COMPOSITE_DRIVES
+	// Accumulate the sizes of consecutive FAT drives & report the accumulated size back in the first FAT partition
+	for (i=0; i<aInfo.iPartitionCount; i++)
+		{
+		aInfo.iEntry[i] = iInfo.iDrives[i].iEntry;
+
+		if (iInfo.iDrives[i].IsUDADrive())
+			{
+			aInfo.iEntry[i].iPartitionLen = 0;
+			for (TInt j=i; j<aInfo.iPartitionCount; j++)
+				{
+				if (iInfo.iDrives[j].IsUDADrive())
+					{
+					aInfo.iEntry[i].iPartitionLen+= iInfo.iDrives[j].iEntry.iPartitionLen;
+					}
+				}
+			iInfo.iDrives[i].iCompositeSize = aInfo.iEntry[i].iPartitionLen;
+			i = j;
+			}
+		}
+#endif
+
+
+	SetTotalSizeInBytes(aInfo.iMediaSizeInBytes);
+
+
+	return KErrCompletion;	// synchronous completion
+	}
+
+/**
+HandleCaps() - 
+
+Return the Caps for a particular drive
+
+Queries the caps from the attached drive, ORs in appropriate paging flags & returns
+*/
+TInt DMediaDriverNFE::HandleCaps(TLocDrvRequest& aReq)
+	{
+	// Get caps from slave drive
+	// NB if we didn't want to alter anything then we could just call ForwardRequest(aReq);
+	TBuf8<sizeof(TLocalDriveCapsV6)> slaveCapsBuf;
+	TLocalDriveCapsV6& slaveCaps = *(TLocalDriveCapsV6*) slaveCapsBuf.Ptr();
+	slaveCapsBuf.SetMax();
+	slaveCapsBuf.FillZ();
+	TInt r = Caps(aReq.Drive()->iDriveNumber, slaveCapsBuf);
+	if (r != KErrNone)
+		return r;
+
+#ifdef COMPOSITE_DRIVES
+	TInt driveNum = aReq.Drive()->iDriveNumber;
+	TInt driveIndex = DriveIndex(driveNum);
+	if (iInfo.iDrives[driveIndex].iCompositeSize)
+		slaveCaps.iSize = iInfo.iDrives[driveIndex].iCompositeSize;
+#endif
+
+	// copy slave caps to returned caps
+	TLocalDriveCapsV6& caps = *(TLocalDriveCapsV6*)aReq.RemoteDes();		
+	caps = slaveCaps;
+
+	// set the paging flags
+#ifdef __DEMAND_PAGING__
+	TLocDrv& drive = *aReq.Drive();
+	if (drive.iPrimaryMedia->iPagingMedia)
+		caps.iMediaAtt|=KMediaAttPageable;
+	if (drive.iPagingDrv)
+		caps.iDriveAtt|=KDriveAttPageable;
+#endif // __DEMAND_PAGING__
+
+	return KErrCompletion;
+	}
+
+
+/**
+AdjustRequest() - 
+
+Adjusts position & length if a request crosses these boundaries:
+- the start of the partition (if RLocalDrive::ELocDrvWholeMedia set)
+- the current encrytion point (iEncryptEndPos) N.B. this will point to the end of the partition 
+  if the drive is fully encrypted
+
+For composite drives, it also adjusts the position, length & drive number as appropriate to cater for 
+crossing partition boundaries
+
+returns ETrue if buffer needs encrypting/decrypting
+*/
+
+TBool DMediaDriverNFE::AdjustRequest(TNfeDriveInfo*& aDriveInfo, TInt64& aCurrentPos, TInt64& aCurrentLen)
+	{
+#ifdef COMPOSITE_DRIVES
+	while (aCurrentPos >= aDriveInfo->iEntry.iPartitionLen)
+		{
+		aCurrentPos-= aDriveInfo->iEntry.iPartitionLen;
+		aDriveInfo++;
+		}
+	if (aCurrentPos + aCurrentLen > aDriveInfo->iEntry.iPartitionLen)
+		aCurrentLen = aDriveInfo->iEntry.iPartitionLen - aCurrentPos;
+#endif
+
+	// do we need to encrypt/decrypt this buffer ?
+	TBool encodeBuffer = EFalse;
+	
+	if ((aDriveInfo->Status() == ENfeEncrypted) || aDriveInfo->Status() == ENfeEncrypting)
+		{
+//		__ASSERT_DEBUG(aDriveInfo->iEncryptEndPos <= aDriveInfo->iEntry.iPartitionBaseAddr + aDriveInfo->iEntry.iPartitionLen, NFE_FAULT());
+
+		if (aCurrentPos < aDriveInfo->iEncryptStartPos)
+			{
+			aCurrentLen = Min(aCurrentLen, aDriveInfo->iEncryptStartPos - aCurrentPos);
+			encodeBuffer = EFalse;
+			}
+		else if (aCurrentPos < aDriveInfo->iEncryptEndPos)
+			{
+			aCurrentLen = Min(aCurrentLen, aDriveInfo->iEncryptEndPos - aCurrentPos);
+			encodeBuffer = ETrue;
+			}
+		else
+			{
+			encodeBuffer = EFalse;
+			}
+		}
+
+	return encodeBuffer;
+	}
+
+
+TInt DMediaDriverNFE::HandleRead(TLocDrvRequest& aReq)
+	{
+	TInt r = KErrNone;
+	TInt64 currentPos = aReq.Pos();
+	TInt64 remainingLength = aReq.Length();
+	TInt desPos = 0;
+	TNfeDriveInfo* di = &iInfo.iDrives[DriveIndex(aReq.Drive()->iDriveNumber)];
+
+//	__KTRACE_PRINT(Kern::Printf("NFE%d: HandleRead pos %lx len %lx status %d", iInstance, currentPos, remainingLength, di->Status()));
+
+
+	di->iReadRequestCount++;
+
+	if (aReq.Flags() & TLocDrvRequest::ECodePaging)
+		di->iCodePagingRequesCount++;
+	if (aReq.Flags() & TLocDrvRequest::EDataPaging)
+		di->iDataPagingReadRequestCount++;
+
+	
+	// just forward the request if the drive is not encrypted
+	if (di->Status() == ENfeDecrypted)
+		return ForwardRequest(aReq);
+
+	
+	while(remainingLength)
+		{
+		TInt64 currentLength = (remainingLength <= KBufSize ? remainingLength : KBufSize);
+
+		TBool decryptBuffer = AdjustRequest(di, currentPos, currentLength);
+
+		// Read from attached drive
+#ifdef __DEMAND_PAGING__
+		if (DMediaPagingDevice::PagingRequest(aReq))
+			r = ReadPaged(di->iLocalDriveNum, currentPos, (TLinAddr) iBuffer, I64LOW(currentLength));
+		else
+#endif
+		r = Read(di->iLocalDriveNum, currentPos, (TLinAddr) iBuffer, I64LOW(currentLength));
+		if(r != KErrNone)
+			break;
+
+		TPtr8 des(iBuffer, I64LOW(currentLength), I64LOW(currentLength));
+
+		// decrypt buffer
+		if (decryptBuffer)
+			DecryptBuffer(des);
+
+		//  write back to user
+		r = aReq.WriteRemote(&des, desPos);
+		if(r != KErrNone)
+			break;
+
+		remainingLength-= currentLength;
+		currentPos+= currentLength;
+		desPos+= I64LOW(currentLength);
+		}
+
+	return r == KErrNone ? KErrCompletion : r;
+	}
+
+TInt DMediaDriverNFE::HandleWrite(TLocDrvRequest& aReq)
+	{
+	TInt r = KErrNone;
+	TInt64 currentPos =  aReq.Pos();
+	TInt64 remainingLength = aReq.Length();
+	TInt desPos = 0;
+	TNfeDriveInfo* di = &iInfo.iDrives[DriveIndex(aReq.Drive()->iDriveNumber)];
+
+//	__KTRACE_PRINT(Kern::Printf("NFE%d: HandleWrite pos %lx len %lx status %d", iInstance, currentPos, remainingLength, di->Status()));
+
+
+	di->iWriteRequestCount++;
+	if (aReq.Flags() & TLocDrvRequest::EDataPaging)
+		di->iDataPagingWriteRequestCount++;
+	
+
+	// just forward the request if the drive is not encrypted
+	if (di->Status() == ENfeDecrypted)
+		return ForwardRequest(aReq);
+
+	while(remainingLength)
+		{
+		TInt64 currentLength = (remainingLength <= KBufSize ? remainingLength : KBufSize);
+
+		TBool encryptBuffer = AdjustRequest(di, currentPos, currentLength);
+
+		// read from user
+		TPtr8 des(iBuffer,0,I64LOW(currentLength));
+		r = aReq.ReadRemote(&des, desPos);
+		if(r != KErrNone)
+			break;
+		
+		// get the length of data read from the user in case user's
+		// descriptor is shorter than advertised
+		currentLength = des.Length();
+		if (currentLength == 0)
+			break;
+
+		// writing to sector zero ?
+		if (currentPos >= di->iEntry.iPartitionBaseAddr && 
+			currentPos < di->iEntry.iPartitionBaseAddr + KSectorSize && 
+			di->IsUDADrive())
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Write to sector #0 detected", iInstance));
+
+
+			TUint8* bootSector = iBuffer;
+			TUint8 bootSectorBuffer[KSectorSize];
+			// writing partial sector ?
+			if (currentPos > di->iEntry.iPartitionBaseAddr || currentLength < KSectorSize)
+				{
+				bootSector = bootSectorBuffer;
+				r = Read(di->iLocalDriveNum, di->iEntry.iPartitionBaseAddr, (TLinAddr) bootSector, KSectorSize);
+				if(r != KErrNone)
+					break;
+				TInt64 readLen = KSectorSize;
+				TBool encryptBuffer = AdjustRequest(di, di->iEntry.iPartitionBaseAddr, readLen);
+				if (encryptBuffer)
+					{
+					TPtr8 des(bootSectorBuffer,KSectorSize,KSectorSize);
+					DecryptBuffer(des);
+					}
+				TInt sectorOffset = (TInt) (currentPos - di->iEntry.iPartitionBaseAddr);
+				TInt64 copyLen = currentLength;
+				if (copyLen > KSectorSize-sectorOffset)
+					copyLen = KSectorSize-sectorOffset;
+				memcpy(bootSectorBuffer+sectorOffset, iBuffer, (TInt) copyLen);
+				}
+
+			if ((di->Status() == ENfeUnmounted || di->Status() == ENfeCorrupted) && 
+				ValidBootSector(bootSector))
+				{
+				__KTRACE_PRINT(Kern::Printf("NFE%d: Setting status to ENfeDecrypted", iInstance ));
+				di->SetStatus(ENfeDecrypted);
+				}
+			di->iUniqueID = VolumeId(bootSector);		// update the Volume ID
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Setting Volume ID to %08X", iInstance, di->iUniqueID ));
+			TBootSectorStatus* bootSectorStatus = (TBootSectorStatus*) iBuffer;
+			if (di->Status() == ENfeEncrypting || di->Status() == ENfeDecrypting)
+				{
+				__KTRACE_PRINT(Kern::Printf("NFE%d: Adding NFE status record to boot sector", iInstance ));
+				bootSectorStatus->iSignature = TBootSectorStatus::ENfeBootSectorSignature;
+				bootSectorStatus->iEncryptEndPos = di->iEncryptEndPos;
+				bootSectorStatus->iStatus = di->Status();
+				bootSectorStatus->iFinalised = EFalse;
+				}
+			}
+
+		// encrypt the buffer
+		if (encryptBuffer)
+			EncryptBuffer(des);
+
+		// write the data to the attached drive
+#ifdef __DEMAND_PAGING__
+		if (DMediaPagingDevice::PagingRequest(aReq))
+			r = WritePaged(di->iLocalDriveNum, currentPos, (TLinAddr) iBuffer, I64LOW(currentLength));
+		else
+#endif
+		r = Write(di->iLocalDriveNum, currentPos, (TLinAddr) iBuffer, I64LOW(currentLength));
+		if(r != KErrNone)
+			break;
+
+		remainingLength-= currentLength;
+		currentPos+= currentLength;
+		desPos+= I64LOW(currentLength);
+		}
+
+	return r == KErrNone ? KErrCompletion : r;
+	}
+
+TInt DMediaDriverNFE::HandleFormat(TLocDrvRequest& aReq)
+	{
+	TInt r = KErrNone;
+	TInt64 currentPos =  aReq.Pos();
+	TInt64 remainingLength = aReq.Length();
+	TNfeDriveInfo* di = &iInfo.iDrives[DriveIndex(aReq.Drive()->iDriveNumber)];
+
+//	__KTRACE_PRINT(Kern::Printf("NFE%d: HandleFormat pos %lx len %lx status %d", iInstance, currentPos, remainingLength, di->Status()));
+
+
+	// just forward the request if the drive is not encrypted
+	if (di->Status() == ENfeDecrypted)
+		return ForwardRequest(aReq);
+
+	// otherwise create a buffer containing NULLs, encrypt it and write that to the attached drive
+	while(remainingLength && r == KErrNone)
+		{
+		TInt64 currentLength = (remainingLength <= KBufSize ? remainingLength : KBufSize);
+
+		TBool encryptBuffer = AdjustRequest(di, currentPos, currentLength);
+
+		memclr(iBuffer, KBufSize);
+		TPtr8 des(iBuffer,KBufSize,KBufSize);
+
+		if (encryptBuffer)
+			EncryptBuffer(des);
+		
+		r = Write(di->iLocalDriveNum, currentPos, (TLinAddr) iBuffer, I64LOW(currentLength));
+		if(r != KErrNone)
+			break;
+
+		remainingLength-= currentLength;
+		currentPos+= currentLength;
+		}
+
+	return r == KErrNone ? KErrCompletion : r;
+	}
+
+
+void DMediaDriverNFE::EncryptBuffer(TDes8& aBuffer)
+	{
+	TInt len = aBuffer.Length();
+	for(TInt i=0; i<len; i++)
+		aBuffer[i] = EncryptByte(aBuffer[i]);
+	}
+
+void DMediaDriverNFE::DecryptBuffer(TDes8& aBuffer)
+	{
+	TInt len = aBuffer.Length();
+	for(TInt i=0; i<len; i++)
+		aBuffer[i] = DecryptByte(aBuffer[i]);
+	}
+
+
+TNfeDriveInfo* DMediaDriverNFE::GetSwapDrive()
+	{
+	for (TInt i=0; i<iInfo.iDriveCount; i++)
+		{
+		TNfeDriveInfo& di = iInfo.iDrives[i];
+		if (di.iEntry.iPartitionType == KPartitionTypePagedData)
+			{
+			return &di;
+			}
+		}
+	return NULL;	// swap drive not found
+	}
+
+/**
+Get the first/next drive to encrypt 
+*/
+
+TNfeDriveInfo* DMediaDriverNFE::NextDrive()
+	{
+	for (iDriveIndex = 0; iDriveIndex<iInfo.iDriveCount; iDriveIndex++)
+		{
+		TNfeDriveInfo& di = iInfo.iDrives[iDriveIndex];
+		TNfeDiskStatus status = iInfo.iDrives[iDriveIndex].Status();
+		if (status == ENfeEncrypting || status == ENfeDecrypting)
+			{
+			di.iEncryptStartPos = di.iEncryptEndPos = di.iEntry.iPartitionBaseAddr;
+
+			// write to boot sector to indicate we are encrypting/decrypting this drive
+			WriteEncryptionStatusToBootSector(di);
+
+			return &di;
+			}
+		}
+	__KTRACE_PRINT(Kern::Printf("NFE%d: Finished encrypting / decrypting", iInstance));
+	iBusy = EFalse;
+	return NULL;
+	}
+
+
+/** 
+Finds the first unencrypted drive & kicks off the idle timer - 
+when this expires the encryption of the drive will start
+*/
+void DMediaDriverNFE::StartEncrypting()
+	{
+	// start encrypting if not already doing so
+	if (!iBusy)
+		{
+		iBusy = ETrue;
+		TNfeDriveInfo* di = NextDrive();
+		if (di)
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Start encrypting drive %d...", iInstance, iInfo.iDrives[iDriveIndex].iLocalDriveNum));
+			iIdleTimer.OneShot(NKern::TimerTicks(KNotBusyInterval));
+			}
+		}
+	}
+
+/** 
+Finds the first unencrypted drive & kicks off the idle timer - 
+when this expires the encryption of the drive will start
+*/
+void DMediaDriverNFE::StartDecrypting()
+	{
+	// start encrypting if not already doing so
+	if (!iBusy)
+		{
+		iBusy = ETrue;
+		TNfeDriveInfo* di = NextDrive();
+		if (di)
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Start decrypting drive %d...", iInstance, iInfo.iDrives[iDriveIndex].iLocalDriveNum));
+			iIdleTimer.OneShot(NKern::TimerTicks(KNotBusyInterval));
+			}
+		}
+	}
+
+/**
+Idle timer callback
+Kicks off a DFC to ensure we are running in the correct thread
+*/
+void DMediaDriverNFE::IdleTimerCallBack(TAny* aMediaDriver)
+	{
+	((DMediaDriverNFE*)aMediaDriver)->iTimerDfc.Add();
+	}
+
+/**
+Idle timer DFC
+*/
+void DMediaDriverNFE::TimerDfcFunction(TAny* aMediaDriver)
+	{
+	((DMediaDriverNFE*) aMediaDriver)->HandleDiskContent();
+	}
+
+
+TBool DMediaDriverNFE::ValidBootSector(TUint8* aBuffer)
+	{
+	if (aBuffer[0] == 0xEB || aBuffer[0] == 0xE9)
+		return ETrue;
+	else
+		return EFalse;
+	}
+
+
+TUint32 DMediaDriverNFE::VolumeId(TUint8* aBuffer)
+	{
+	TUint16 rootDirEntries;
+	TUint32 uniqueID;   
+    memcpy(&rootDirEntries,&aBuffer[17], 2);	// 17   TUint16 iRootDirEntries
+	TBool fat32 = rootDirEntries == 0;
+	TInt pos = fat32 ? 67 : 39;		// get position of VolumeID
+	memcpy(&uniqueID,&aBuffer[pos],4);
+	return uniqueID;
+	}
+
+void DMediaDriverNFE::CheckBootSector(TNfeDriveInfo &aDi)
+	{
+	TNfeDiskStatus  fatBootSectorStatus = ENfeDecrypted;
+
+	// Try to determine whether the FAT boot sector is encypted
+	if (ValidBootSector(iBuffer))
+		{
+		fatBootSectorStatus = ENfeDecrypted;
+		__KTRACE_PRINT(Kern::Printf("NFE%d: FAT Boot sector is decrypted", iInstance));
+		}
+	else
+		{
+		TPtr8 des(iBuffer, KSectorSize, KSectorSize);
+		DecryptBuffer(des);
+		if (ValidBootSector(iBuffer))
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: FAT Boot sector is encrypted", iInstance));
+			fatBootSectorStatus = ENfeEncrypted;
+			}
+		else
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: FAT Boot sector is corrupted", iInstance));
+			fatBootSectorStatus = ENfeCorrupted;
+			}
+		}
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: fatBootSectorStatus %d", iInstance, fatBootSectorStatus));
+
+	// Find out whether the volume has changed
+	TUint32 uniqueID = VolumeId(iBuffer);   
+	TBool volumeChanged = uniqueID != aDi.iUniqueID;
+	__KTRACE_PRINT(Kern::Printf("NFE%d: Old Volume ID %08X", iInstance, aDi.iUniqueID));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: New Volume ID %08X", iInstance, uniqueID));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: volumeChanged %d", iInstance, volumeChanged));
+	aDi.iUniqueID = uniqueID;
+
+
+
+	TBootSectorStatus* bootSectorStatus = (TBootSectorStatus*) iBuffer;
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: CheckBootSector, iSignature %08X", iInstance, bootSectorStatus->iSignature));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: CheckBootSector, iStatus %d", iInstance, bootSectorStatus->iStatus));
+	__KTRACE_PRINT(Kern::Printf("NFE%d: CheckBootSector, iEncryptEndPos %lx", iInstance, bootSectorStatus->iEncryptEndPos));
+
+
+	/*
+	If there IS NFE info in the boot sector, restore the encryption settings - 
+	unless the 'finalised' flag is clear which indicates that the media was removed or power was lost
+	while encrypting the device...
+
+	If there is no NFE info in the boot sector and there has been a volume change, then we can decide  
+	whether the drive is encrypted/decrypted/corrupt by examining the boot sector
+	*/
+	if (volumeChanged && 
+		fatBootSectorStatus != ENfeCorrupted &&
+		bootSectorStatus->iSignature == TBootSectorStatus::ENfeBootSectorSignature &&
+		!bootSectorStatus->iFinalised)
+		{
+		SetStatus(aDi, ENfeCorrupted);
+		}
+	else if (volumeChanged && 
+		fatBootSectorStatus != ENfeCorrupted &&
+		bootSectorStatus->iFinalised &&
+		bootSectorStatus->iSignature == TBootSectorStatus::ENfeBootSectorSignature &&
+		(bootSectorStatus->iStatus == ENfeDecrypting || bootSectorStatus->iStatus == ENfeEncrypting))
+		{
+		SetStatus(aDi, bootSectorStatus->iStatus);
+		aDi.iEncryptEndPos = bootSectorStatus->iEncryptEndPos;
+
+		// write to boot sector to indicate we are no longer finalised
+		WriteEncryptionStatusToBootSector(aDi, EFalse);	
+
+		iBusy = ETrue;
+		}
+	else if (volumeChanged || aDi.Status() == ENfeUnmounted)
+		{
+		SetStatus(aDi, fatBootSectorStatus);
+		if (aDi.Status() == ENfeEncrypted)
+			{
+			aDi.iEncryptStartPos = aDi.iEntry.iPartitionBaseAddr;
+			aDi.iEncryptEndPos = aDi.iEntry.iPartitionBaseAddr + aDi.iEntry.iPartitionLen;
+			}
+		}
+	}
+
+
+TInt DMediaDriverNFE::WriteEncryptionStatusToBootSector(TNfeDriveInfo &aDi, TBool aFinalised)
+	{
+	if (!aDi.IsUDADrive())
+		return KErrNone;
+
+	aDi.iDriveFinalised = aFinalised;
+
+	TNfeDiskStatus status = aDi.Status();
+
+	TInt64 currentPos = aDi.iEntry.iPartitionBaseAddr;
+	TInt64 currentLen = KSectorSize;
+	TNfeDriveInfo* di = &aDi;
+	TBool encodeBuffer = EFalse;
+
+	if (status == ENfeEncrypting || status == ENfeEncrypted || status == ENfeDecrypting)
+		encodeBuffer = AdjustRequest(di, currentPos, currentLen);
+
+
+	TInt r = Read(di->iLocalDriveNum, di->iEntry.iPartitionBaseAddr, (TLinAddr) iBuffer, KSectorSize);
+	if (r != KErrNone)
+		return r;
+	TPtr8 des(iBuffer, I64LOW(currentLen), I64LOW(currentLen));
+
+	if (encodeBuffer)
+		DecryptBuffer(des);
+
+
+	TBootSectorStatus* bootSectorStatus = (TBootSectorStatus*) iBuffer;
+
+	if (status == ENfeEncrypting || status == ENfeDecrypting)
+		{
+		bootSectorStatus->iSignature = TBootSectorStatus::ENfeBootSectorSignature;
+		bootSectorStatus->iEncryptEndPos = di->iEncryptEndPos;
+		bootSectorStatus->iStatus = status;
+		bootSectorStatus->iFinalised = aFinalised;
+		}
+	else
+		{
+		bootSectorStatus->iSignature = 0;
+		bootSectorStatus->iEncryptEndPos = 0;
+		bootSectorStatus->iStatus = ENfeUnmounted;
+		bootSectorStatus->iFinalised = EFalse;
+		}
+
+	if (encodeBuffer)
+		EncryptBuffer(des);
+
+
+	r = Write(di->iLocalDriveNum, di->iEntry.iPartitionBaseAddr, (TLinAddr) iBuffer, KSectorSize);
+	return r;
+	}
+
+
+/**
+HandleDiskContent - 
+
+Called from Idle timer DFC
+
+Starts encrypting the current drive (iDrives[iDriveIndex]) from the current encryption position (iEncryptEndPos)
+*/
+TInt DMediaDriverNFE::HandleDiskContent()
+	{
+	TNfeDriveInfo* di = &iInfo.iDrives[iDriveIndex];
+
+	__KTRACE_PRINT(Kern::Printf("NFE%d: Starting to encrypt Drive %d at pos %lx", iInstance, di->iLocalDriveNum, di->iEncryptEndPos));
+
+	if (di->iDriveFinalised)
+		{
+	    __KTRACE_PRINT(Kern::Printf("HandleDiskContent aborting as drive has been finalised", iInstance));
+		return KErrNone;
+		}
+
+//	TInt KBackgroundPriority = 7;						//*test*
+//	Kern::SetThreadPriority(KBackgroundPriority);		//*test*
+
+	TInt r = KErrNone;
+	for (;;)
+		{
+		// If we've finished encryting this drive, change the state and move on to the next drive
+		if (r != KErrNone || di->iEncryptEndPos >= di->iEntry.iPartitionBaseAddr + di->iEntry.iPartitionLen)
+			{
+			if (di->Status() == ENfeEncrypting)
+				{
+				__KTRACE_PRINT(Kern::Printf("NFE%d: Finished encrypting Drive %d r %d", iInstance, di->iLocalDriveNum, r));
+				SetStatus(*di,  r == KErrNone ? ENfeEncrypted : ENfeCorrupted);
+				}
+			if (di->Status() == ENfeDecrypting)
+				{
+				__KTRACE_PRINT(Kern::Printf("NFE%d: Finished decrypting Drive %d r %d", iInstance, di->iLocalDriveNum, r));
+				SetStatus(*di,  r == KErrNone ? ENfeDecrypted : ENfeCorrupted);
+				}
+			
+			// write to boot sector to indicate we have finished encrypting/decrypting this drive
+			r = WriteEncryptionStatusToBootSector(*di);
+
+			di = NextDrive();
+			if (di == NULL)
+				{
+				r = KErrCompletion;
+				break;
+				}
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Starting to encrypt Drive %d", iInstance, iInfo.iDrives[iDriveIndex].iLocalDriveNum));
+			}
+
+		// If this media or any of the attached media are busy, stop encrypting & wait for the next idle timeout
+		if (MediaBusy(di->iLocalDriveNum))
+			{
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Media is busy !!!", iInstance));
+			r = KErrNone;	// goto sleep & wait for another timer event
+			break;
+			}
+
+		TInt64& pos = di->iEncryptEndPos;
+		TInt64 partitionEnd = di->iEntry.iPartitionBaseAddr + di->iEntry.iPartitionLen;
+		TInt len = (TInt) Min (partitionEnd - pos, KBufSize);
+
+#if defined(TRACE_ENABLED)
+		// print position every 1/16 of the partition size
+		TInt64 printPos = Max((di->iEntry.iPartitionLen >> 4) & ~(KBufSize-1), KBufSize);
+		if (((di->iEncryptEndPos - di->iEncryptStartPos)% printPos) == 0) 
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Encrypting drive %d from %lx to %lx end %lx", iInstance, di->iLocalDriveNum, pos, pos + len, partitionEnd));
+#endif
+//		__KTRACE_PRINT(Kern::Printf("NFE%d: Encrypting drive %d from %lx to %lx end %lx", iInstance, di->iLocalDriveNum, pos, pos + len, partitionEnd));
+
+
+		// Read a buffer, encrypt it, and then write it back
+		// retry in case of media change
+		const TInt KRetries = 5;
+		r = KErrNotReady;
+		for (TInt i=0; r == KErrNotReady && i < KRetries; i++)
+			{
+			r = Read(di->iLocalDriveNum, pos, (TLinAddr) iBuffer, len);
+			if (r != KErrNone)
+				continue;
+
+			TPtr8 des(iBuffer,len,len);
+			if (di->Status() == ENfeEncrypting)
+				EncryptBuffer(des);
+			else
+				DecryptBuffer(des);
+			
+			r = Write(di->iLocalDriveNum, pos, (TLinAddr) iBuffer, len);
+			}
+
+		if (r == KErrNone)
+			pos+= len;
+
+		if (di->iProgressToUiProperty)	// no iProgressToUiProperty for swap drive
+			{
+			TInt progress = (TInt) (KNfeDiskOpReady * (pos - di->iEntry.iPartitionBaseAddr) / di->iEntry.iPartitionLen);
+//			__KTRACE_PRINT(Kern::Printf("NFE%d: Progess %d ", progress));
+			((RPropertyRef*) (di->iProgressToUiProperty))->Set( progress ); // Return value ignored
+			}
+		}
+	
+	__KTRACE_PRINT(Kern::Printf("NFE%d: HandleDiskContent returned %d", iInstance, r));
+
+	// If not completed, start the idle timer & try again later
+	if (r != KErrCompletion)
+		iIdleTimer.OneShot(NKern::TimerTicks(KNotBusyInterval));
+
+//	Kern::SetThreadPriority(KNfeThreadPriority);	//*test*
+	
+	return r;
+	}
+
+
+
+DECLARE_EXTENSION_PDD()
+	{
+	__KTRACE_PRINT(Kern::Printf("DECLARE_EXTENSION_PDD()"));
+	return new DPhysicalDeviceMediaNFE;
+	}
+
+DECLARE_STANDARD_EXTENSION()
+	{
+	__KTRACE_PRINT(Kern::Printf("DECLARE_STANDARD_EXTENSION()"));
+
+
+	// Create the media driver factory object and register this with the kernel
+	__KTRACE_PRINT(Kern::Printf("Creating NFE PDD"));
+	DPhysicalDeviceMediaNFE* device = new DPhysicalDeviceMediaNFE;
+	if (device == NULL)
+		return KErrNoMemory;
+	TInt r = Kern::InstallPhysicalDevice(device);
+	__KTRACE_PRINT(Kern::Printf("Installing NFE PDD in extension init - name %s r:%d", NFE_DRIVENAME, r));
+	if (r != KErrNone)
+		return r;
+
+	TInt swapInstance = KErrNotFound;
+#if defined (__DEMAND_PAGING__)
+	swapInstance = SwapInstance();
+#endif
+
+	DPrimaryMediaExt* primaryMedia[NFE_INSTANCE_COUNT];
+	TInt instance;
+
+	for (instance=0; instance<NFE_INSTANCE_COUNT; instance++)
+		{
+		// Register this media device & define which drives we want to attach to.
+		// These drives must already be registered with the local media subsystem
+		// i.e. this media's kernel extension must be defined AFTER any attached
+		// media's kernel extension in the appropriate .IBY file
+		__KTRACE_PRINT(Kern::Printf("NFE%d: Creating NFE primary media", instance));
+		DPrimaryMediaExt* pM = new DPrimaryMediaExt(instance);
+		if (pM == NULL)
+			return KErrNoMemory;
+		primaryMedia[instance] = pM;
+
+		_LIT(KMediaThreadName,"NfeThread?");
+		HBuf* pMediaThreadName = HBuf::New(KMediaThreadName);
+		(*pMediaThreadName)[9] = (TUint8) ('0' + (TUint8) instance);
+
+		TInt r = Kern::DfcQInit(&pM->iNfeDfcQ,KNfeThreadPriority,pMediaThreadName);
+		if (r != KErrNone)
+			return r;
+
+#ifdef CPU_AFFINITY_ANY
+		NKern::ThreadSetCpuAffinity((NThread*)(pM->iNfeDfcQ.iThread), KCpuAffinityAny);
+#endif
+		
+
+		pM->iDfcQ = &pM->iNfeDfcQ;
+		pM->iMsgQ.Receive();
+
+
+		const TInt* driveList = DriveList(instance);
+		TInt driveCount = DriveCount(instance);
+
+		TBuf<4> driveName(_L("NFE?"));
+		driveName[3] = (TUint8) ('0' + (TUint8) instance);
+
+		
+		r = LocDrv::RegisterMediaDevice(
+			MEDIA_DEVICE_NFE, 
+			driveCount, driveList,
+			pM, NFE_NUMMEDIA, driveName);
+		if (r != KErrNone)
+			return r;
+
+
+#if defined (__DEMAND_PAGING__)
+		if (PagingType(instance))
+			{
+			// Define which of the drives we have already attached to have code or data paging enabled 
+			const TInt* pageDriveList = PageDriveList(instance);
+			TInt pageDriveCount = PageDriveCount(instance);
+
+			r = LocDrv::RegisterPagingDevice(pM,pageDriveList,pageDriveCount,PagingType(instance),SECTOR_SHIFT,NFE_NUM_PAGES);
+			__KTRACE_PRINT(Kern::Printf("NFE%d: Installing NFE PagingDevice in extension init - r:%d", pM->iInstance, r));
+			// Ignore error if demand paging not supported by kernel
+			if (r == KErrNotSupported)
+				r = KErrNone;
+			if (r != KErrNone)
+				return r;
+			}
+
+
+#endif	// __NAND_DEMAND_PAGING__
+
+		/*
+		If there is a swap partition we need to make sure all instances have their PartitionInfo() called
+		so that we can flag the swap partition as 'encrypted' if there are any encrypted drives at all
+		*/
+		if (swapInstance != KErrNotFound)
+			{
+			TBuf8<sizeof(TLocalDriveCapsV6)> capsBuf;
+			capsBuf.SetMax();
+			capsBuf.FillZ();
+			DLocalDrive::Caps(driveList[0], capsBuf);
+			}
+		}
+		
+
+	// If we encounter an encrypted drive belonging to ANY NFE instance, then assume the swap partition is 
+	// encrypted too. We need to do this because the swap partition has no equivalent of the boot sector
+	if (swapInstance != KErrNotFound)
+		{
+		__KTRACE_PRINT(Kern::Printf("NFE: Searching for encrypted drives to determine whether swap partition should be encrypted..."));
+		TBool encryptedDriveFound = EFalse;
+		TNfeDriveInfo* swapDriveInfo = NULL;
+		for (instance=0; instance<NFE_INSTANCE_COUNT; instance++)
+			{
+			DPrimaryMediaExt* pM = primaryMedia[instance];
+			DMediaDriverNFE* mediaDriver = (DMediaDriverNFE*) pM->iDriver;
+			__ASSERT_ALWAYS(mediaDriver, NFE_FAULT());
+
+			if (swapDriveInfo == NULL)
+				swapDriveInfo = mediaDriver->GetSwapDrive();
+
+			for (TInt i=0; i<mediaDriver->iInfo.iDriveCount; i++)
+				{
+				TNfeDriveInfo& di = mediaDriver->iInfo.iDrives[i];
+				__KTRACE_PRINT(Kern::Printf("NFE%d: Testing drive %d DriveLetter %c status %s", 
+					instance, di.iLocalDriveNum, (TInt) DriveLetterToAscii(di.iDriveLetter), DriveStatus(di.Status()) ));
+				if (di.Status() == ENfeEncrypted || di.Status() == ENfeEncrypting)
+					encryptedDriveFound = ETrue;
+				}
+			}
+		if (swapDriveInfo)
+			{
+			swapDriveInfo->SetStatus(encryptedDriveFound ? ENfeEncrypted : ENfeDecrypted);
+			swapDriveInfo->iEncryptEndPos = swapDriveInfo->iEntry.iPartitionBaseAddr + swapDriveInfo->iEntry.iPartitionLen;
+
+			__KTRACE_PRINT(Kern::Printf("NFE: Setting swap partition state to %s...", DriveStatus(swapDriveInfo->Status())));
+			}
+		}
+
+
+	return r;
+	}
+
+