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

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

	TInt iPhysDevIndex;

	TInt iRequestCount;

#ifdef __DEMAND_PAGING__

	DMediaPagingDevice* iPagingDevice;

	TInt iPageSizeMsk;			// Mask of page size (e.g. 4096-1 -> 4095)

	TInt iMediaChanges;

#endif

	};

#ifdef __DEMAND_PAGING__

DMediaPagingDevice* ThePagingDevices[KMaxLocalDrives];

DPrimaryMediaBase* TheRomPagingMedia = NULL;

DPrimaryMediaBase* TheDataPagingMedia = 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;}

inline TBool RomPagingDfcQ(DPrimaryMediaBase* aPrimaryMedia)

	{return TheRomPagingMedia && TheRomPagingMedia->iDfcQ == aPrimaryMedia->iDfcQ;}

/* 

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

*/

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

	{

	if (iPreAllocatedDataLock)

		{

		iPreAllocatedDataLock->Cleanup();

		delete iPreAllocatedDataLock;

		}

	for (TInt n=0; n<iObjectCount; n++)

		{

		SVirtualPinContainer& virtualPinContainer = iVirtualPinContainers[n];

		if (virtualPinContainer.iObject)

			Kern::DestroyVirtualPinObject(virtualPinContainer.iObject);

		}

	delete [] iVirtualPinContainers;

	}

TInt DPinObjectAllocator::Construct(TInt aObjectCount, TUint aNumPages)

	{

	TInt pageSize = Kern::RoundToPageSize(1);

	iFragmentGranularity = pageSize * aNumPages;

	__KTRACE_OPT2(KBOOT,KLOCDPAGING,Kern::Printf("Fragmentation granularity set to 0x%x", iFragmentGranularity));

	// construct the paging lock containing pre-allocated buffers

	iPreAllocatedDataLock = new DFragmentationPagingLock();

	if(!iPreAllocatedDataLock)

		return KErrNoMemory;

	TInt r = iPreAllocatedDataLock->Construct(aNumPages);

	if (r != KErrNone)

		return r;

	SVirtualPinContainer* iVirtualPinContainers = new SVirtualPinContainer[aObjectCount];

	if (iVirtualPinContainers == NULL)

		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)

			return KErrNoMemory;

		iFreeQ.Add(&pinContainer.iLink);

		}

	return KErrNone;

	}

/** 

returns a SVirtualPinContainer object or NULL if NULL available

*/

DPinObjectAllocator::SVirtualPinContainer* DPinObjectAllocator::AcquirePinObject()

	{

	SVirtualPinContainer* pinContainer = NULL;

	NKern::FMWait(&iLock);

	if (!iFreeQ.IsEmpty())

		{

		SDblQueLink* link = iFreeQ.First();

		pinContainer = _LOFF(link, SVirtualPinContainer, iLink);

		link->Deque();

		}

	NKern::FMSignal(&iLock);

	return pinContainer;

	}

/** 

returns a SVirtualPinContainer object to the pool

*/

void DPinObjectAllocator::ReleasePinObject(SVirtualPinContainer* aPinContainer)

	{

	NKern::FMWait(&iLock);

	iFreeQ.Add(&aPinContainer->iLink);

	NKern::FMSignal(&iLock);

	}

#endif	// __DEMAND_PAGING__

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

 * Local drive device base class

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

DECLARE_EXTENSION_LDD()

	{

	return new DLocalDriveFactory;

	}

DLocalDriveFactory::DLocalDriveFactory()

//

// Constructor

//

	{

	iParseMask=KDeviceAllowUnit|KDeviceAllowInfo;

	iUnitsMask=~(0xffffffff<<KMaxLocalDrives);

	iVersion=TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion);

	}

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.

//

	{

	aChannel=new DLocalDrive;

	return aChannel?KErrNone:KErrNoMemory;

	}

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

 * Local drive interface class

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

DLocalDrive::DLocalDrive()

	{

//	iLink.iNext=NULL;

	}

DLocalDrive::~DLocalDrive()

	{

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

	}

TInt DLocalDrive::DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer)

	{

	if(!Kern::CurrentThreadHasCapability(ECapabilityTCB,__PLATSEC_DIAGNOSTIC_STRING("Checked by ELOCD.LDD (Local Media Driver)")))

		return KErrPermissionDenied;

	if (!Kern::QueryVersionSupported(TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion),aVer))

		return KErrNotSupported;

	NKern::ThreadEnterCS();

	TInt r = Kern::CreateClientDataRequest(iNotifyChangeRequest);

	NKern::ThreadLeaveCS();

	if (r != KErrNone)

		return r;

	DThread& t=Kern::CurrentThread();

	NKern::LockSystem();

	t.AddCleanup(&iCleanup);

	NKern::UnlockSystem();

	t.Open();

	iNotifyChangeRequest->SetDestPtr((TBool*) anInfo);

	iDrive=TheDrives[aUnit];

	if (!iDrive)

		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

	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("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)

	{

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

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

				r=iDrive->Request(m);

				__TRACE_TIMING(3);

				}

			m.CloseRemoteThread();

			break;

			}

		case RLocalDrive::EControlWrite:

			{

			m.Id()=EWrite;

			r=m.ProcessMessageData(a1);

			if (r==KErrNone)

				r=iDrive->Request(m);

			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(r == KErrNone && iDrive->iMedia != NULL && iDrive->iMedia->iDriver != NULL)

				{

				// Fill in default media size if not specified by the driver

				//

				// - This uses the members of TLocalDriveCapsV4 which was primarily used

				//   to report NAND flash characteristics, but are general enough to be

				//	 used to report the size of any type of media without adding yet

				//	 another extension to TLocalDriveCapsVx.

				//

				TLocalDriveCapsV4& caps = *(TLocalDriveCapsV4*)capsBuf.Ptr();

				if(caps.iSectorSizeInBytes == 0)

					{

					// Fill in a default value for the disk sector size

					caps.iSectorSizeInBytes = 512;

					// Zero the number of sectors, as a sector count makes no sense without a sector size

					//  - Fault in debug mode if a sector count is provided to ensure that media driver creators

					//	  set this value,but in release mode continue gracefully be recalculating the sector count.

					__ASSERT_DEBUG(caps.iNumberOfSectors == 0, LOCM_FAULT());

					caps.iNumberOfSectors  = 0;

					caps.iNumPagesPerBlock = 1;	// ...to ensure compatiility with NAND semantics

					}

				if(caps.iNumberOfSectors == 0)

					{

					const Int64 totalSizeInSectors = iDrive->iMedia->iDriver->TotalSizeInBytes() / caps.iSectorSizeInBytes;

					__ASSERT_DEBUG(I64HIGH(totalSizeInSectors) == 0, LOCM_FAULT());

					if(I64HIGH(totalSizeInSectors) == 0)

						{

						caps.iNumberOfSectors = I64LOW(totalSizeInSectors);

						}

					}

				}

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

				r=iDrive->Request(m);

			break;

			}

		case RLocalDrive::EControlEnlarge:

			if ((TInt)a1<0)

				{

				r=KErrArgument;

				break;

				}

			m.Length()=(TInt)a1;

			m.Id()=EEnlarge;

			r=iDrive->Request(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;

			r=iDrive->Request(m);

			break;

			}

		case RLocalDrive::EControlForceMediaChange:

			m.Pos()=(TInt)a1;

			m.Id()=EForceMediaChange;

			r = iDrive->Request(m);

			break;

		case RLocalDrive::EControlMediaDevice:

			r=iDrive->iPrimaryMedia->iDevice;

			break;

		case RLocalDrive::EControlIsRemovable:

			{

			TInt sockNum;

			r=iDrive->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;