--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/drivers/medint/iram.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,333 @@
+// Copyright (c) 1996-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\medint\iram.cpp
+// 
+//
+
+#include "locmedia.h"
+#include "platform.h"
+#include "variantmediadef.h"
+
+_LIT(KPddName, "Media.IRam");
+
+class DPhysicalDeviceMediaIRam : public DPhysicalDevice
+	{
+public:
+	DPhysicalDeviceMediaIRam();
+	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 DMediaDriverIRam : public DMediaDriver
+	{
+public:
+	DMediaDriverIRam(TInt aMediaId);
+public:
+	// replacing pure virtual
+	virtual TInt Request(TLocDrvRequest& aRequest);
+	virtual void Disconnect(DLocalDrive* aLocalDrive, TThreadMessage* aMsg);
+	virtual TInt PartitionInfo(TPartitionInfo &anInfo);
+	virtual void NotifyPowerDown();
+	virtual void NotifyEmergencyPowerDown();
+public:
+	TInt DoCreate(TInt aMediaId);
+	TInt Caps(TLocDrvRequest& aRequest);
+	TInt Read(TLocDrvRequest& aRequest);
+	TInt Write(TLocDrvRequest& aRequest);
+	TInt Format(TLocDrvRequest& aRequest);
+	TInt Enlarge(TLocDrvRequest& aRequest);
+	TInt Reduce(TLocDrvRequest& aRequest);
+	};
+
+DPhysicalDeviceMediaIRam::DPhysicalDeviceMediaIRam()
+//
+// Constructor
+//
+	{
+	iUnitsMask=0x1;
+	iVersion=TVersion(KMediaDriverInterfaceMajorVersion,KMediaDriverInterfaceMinorVersion,KMediaDriverInterfaceBuildVersion);
+	}
+
+TInt DPhysicalDeviceMediaIRam::Install()
+//
+// Install the Internal Ram Media PDD.
+//
+	{
+
+	return SetName(&KPddName);
+	}
+
+void DPhysicalDeviceMediaIRam::GetCaps(TDes8& /*aDes*/) const
+//
+// Return the media drivers capabilities.
+//
+	{
+	}
+
+TInt DPhysicalDeviceMediaIRam::Create(DBase*& aChannel, TInt aMediaId, const TDesC8* /* anInfo */,const TVersion &aVer)
+//
+// Create an Internal Ram media driver.
+//
+	{
+	if (!Kern::QueryVersionSupported(iVersion,aVer))
+		return KErrNotSupported;
+	TInt r=KErrNoMemory;
+	DMediaDriverIRam* pD=new DMediaDriverIRam(aMediaId);
+	aChannel=pD;
+	if (pD)
+		r=pD->DoCreate(aMediaId);
+	TInternalRamDrive::Unlock();
+	return r;
+	}
+
+TInt DPhysicalDeviceMediaIRam::Validate(TInt aDeviceType, const TDesC8* /*anInfo*/, const TVersion& aVer)
+	{
+	if (!Kern::QueryVersionSupported(iVersion,aVer))
+		return KErrNotSupported;
+	if (aDeviceType!=MEDIA_DEVICE_IRAM)
+		return KErrNotSupported;
+	return KErrNone;
+	}
+
+TInt DPhysicalDeviceMediaIRam::Info(TInt aFunction, TAny*)
+//
+// Return the priority of this media driver
+//
+	{
+	if (aFunction==EPriority)
+		return KMediaDriverPriorityNormal;
+	return KErrNotSupported;
+	}
+
+DMediaDriverIRam::DMediaDriverIRam(TInt aMediaId)
+//
+// Constructor.
+//
+	:	DMediaDriver(aMediaId)
+	{}
+
+TInt DMediaDriverIRam::DoCreate(TInt /*aMediaId*/)
+//
+// Create the media driver.
+//
+	{
+	
+	TInt size=TInternalRamDrive::Size();
+	if (size<0)
+		return KErrGeneral;		// no RAM drive!
+	SetTotalSizeInBytes(size);
+	return(KErrNone);
+	}
+
+TInt DMediaDriverIRam::Request(TLocDrvRequest& m)
+	{
+	TInt request=m.Id();
+	__KTRACE_OPT(KLOCDRV,Kern::Printf(">DMediaDriverIRam::Request %d",request));
+	TInt r=KErrNotSupported;
+	NKern::ThreadEnterCS();
+	TInternalRamDrive::Wait();
+	switch (request)
+		{
+		case DLocalDrive::ECaps:
+			r=Caps(m);
+			break;
+		case DLocalDrive::ERead:
+			r=Read(m);
+			break;
+		case DLocalDrive::EWrite:
+			r=Write(m);
+			break;
+		case DLocalDrive::EFormat:
+			r=Format(m);
+			break;
+		case DLocalDrive::EEnlarge:
+			r=Enlarge(m);
+			break;
+		case DLocalDrive::EReduce:
+			r=Reduce(m);
+			break;
+		default:
+			r=KErrNotSupported;
+			break;
+		}
+	TInternalRamDrive::Signal();
+	NKern::ThreadLeaveCS();
+	__KTRACE_OPT(KLOCDRV,Kern::Printf("<DMediaDriverIRam::Request %d",r));
+	return r;
+	}
+
+void DMediaDriverIRam::Disconnect(DLocalDrive* /*aLocalDrive*/, TThreadMessage*)
+	{
+	// no action required
+	}
+
+void DMediaDriverIRam::NotifyPowerDown()
+	{
+	// no action required
+	}
+
+void DMediaDriverIRam::NotifyEmergencyPowerDown()
+	{
+	// no action required
+	}
+
+TInt DMediaDriverIRam::Caps(TLocDrvRequest& m)
+	{
+	TLocalDriveCapsV6& caps=*(TLocalDriveCapsV6*)m.RemoteDes();
+	caps.iType=EMediaRam;
+	caps.iBattery=EBatNotSupported;
+	caps.iDriveAtt=KDriveAttLocal|KDriveAttInternal;
+	caps.iMediaAtt=KMediaAttVariableSize|KMediaAttFormattable;
+    caps.iBaseAddress=(TUint8*)TInternalRamDrive::Base();
+	caps.iFileSystemId=KDriveFileSysFAT;
+	caps.iPartitionType=KPartitionTypeFAT16;
+	caps.iSize=m.Drive()->iPartitionLen;
+	caps.iHiddenSectors=0;
+	caps.iEraseBlockSize=TInternalRamDrive::MaxSize();	// overload for RAM drive to avoid
+														// F32 depending on memory model
+	caps.iBlockSize=1;
+	return KErrNone;									
+	}
+
+TInt DMediaDriverIRam::Read(TLocDrvRequest& m)
+	{
+	Int64 pos=m.Pos();
+	Int64 length=m.Length();
+	if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+		return KErrGeneral;
+	TInt p=(TInt)pos;
+	TInt l=(TInt)length;
+	if (p+l>TInternalRamDrive::Size())
+		return KErrGeneral;
+	TPtrC8 des((TUint8*)TInternalRamDrive::Base()+p,l);
+	TInt r=m.WriteRemote(&des,0);
+	return r;
+	}
+
+TInt DMediaDriverIRam::Write(TLocDrvRequest& m)
+	{
+	Int64 pos=m.Pos();
+	Int64 length=m.Length();
+	if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+		return KErrGeneral;
+	TInt p=(TInt)pos;
+	TInt l=(TInt)length;
+	if (p+l>TInternalRamDrive::Size())
+		return KErrGeneral;
+	TPtr8 des((TUint8*)TInternalRamDrive::Base()+p,l,l);
+	TInt r=m.ReadRemote(&des,0);
+	return r;
+	}
+
+TInt DMediaDriverIRam::Format(TLocDrvRequest& m)
+	{
+	Int64 pos=m.Pos();
+	Int64 length=m.Length();
+	if (length<0 || pos<0 || (pos+length)>KMaxTInt)
+		return KErrGeneral;
+	TInt p=(TInt)pos;
+	TInt l=(TInt)length;
+	if (p+l>TInternalRamDrive::Size())
+		return KErrGeneral;
+	memclr((TUint8*)TInternalRamDrive::Base()+p, l);
+	return KErrNone;
+	}
+
+TInt DMediaDriverIRam::Enlarge(TLocDrvRequest& m)
+//
+// Enlarge the drive
+//
+	{
+	TInt length=(TInt)m.Length();
+	__KTRACE_OPT(KLOCDRV,Kern::Printf(">IRam::Enlarge (%d)",length));
+ 
+	Int64 newLen=TotalSizeInBytes();
+	newLen+=length;
+	if (newLen>KMaxTInt)
+		return(KErrGeneral);
+
+	TInt r=TInternalRamDrive::Adjust((TInt)newLen);
+	if (r==KErrNone)
+		{
+		SetTotalSizeInBytes(newLen,m.Drive());
+		__KTRACE_OPT(KLOCDRV,Kern::Printf("Enlarge-Success (S:0x%lx RS:%d)",TotalSizeInBytes(),TInternalRamDrive::Size()));
+		}
+	else if (r==KErrNoMemory)
+		r=KErrDiskFull;
+	return r;
+	}
+
+TInt DMediaDriverIRam::Reduce(TLocDrvRequest& m)
+//
+// Reduce in size the drive
+//
+	{
+	Int64 pos=m.Pos();
+	TInt length=(TInt)m.Length();
+	if (pos>KMaxTInt)
+		return(KErrGeneral);
+
+	__KTRACE_OPT(KLOCDRV,Kern::Printf(">IRam::ReduceSize (%d@%d)",length,(TInt)pos));
+
+	TUint8 *Trg=(TUint8*)TInternalRamDrive::Base()+(TInt)pos;
+	TInt len=TInternalRamDrive::Size()-((TInt)pos+length);
+	memmove((TAny*)Trg,(TAny*)(Trg+length),len);
+	len=TInternalRamDrive::Size()-length;
+	TInt r=TInternalRamDrive::Adjust(len);
+	if (r==KErrNone)
+		{
+		SetTotalSizeInBytes(len,m.Drive());
+		__KTRACE_OPT(KLOCDRV,Kern::Printf("ReduceSize-Success (S:0x%lx RS:%d)",TotalSizeInBytes(),TInternalRamDrive::Size()));
+		}
+	return r;
+	}
+
+TInt DMediaDriverIRam::PartitionInfo(TPartitionInfo& anInfo)
+//
+// Return partition information on the media.
+//
+	{
+	
+	anInfo.iPartitionCount=1;
+	anInfo.iEntry[0].iPartitionBaseAddr=0;
+	anInfo.iEntry[0].iPartitionLen=anInfo.iMediaSizeInBytes=TotalSizeInBytes();
+	anInfo.iEntry[0].iPartitionType=KPartitionTypeFAT16;
+	return KErrNone;
+	}
+
+DECLARE_EXTENSION_PDD()
+	{
+	return new DPhysicalDeviceMediaIRam;
+	}
+
+static const TInt IRamDriveNumbers[IRAM_DRIVECOUNT]={IRAM_DRIVELIST};	
+_LIT(KIRamDriveName,IRAM_DRIVENAME);
+
+DECLARE_STANDARD_EXTENSION()
+	{
+	__KTRACE_OPT(KBOOT,Kern::Printf("Registering IRAM drive"));
+	TInt r=KErrNoMemory;
+	DPrimaryMediaBase* pM=new DPrimaryMediaBase;
+	if (pM)
+		{
+		r=LocDrv::RegisterMediaDevice(MEDIA_DEVICE_IRAM,IRAM_DRIVECOUNT,&IRamDriveNumbers[0],pM,IRAM_NUMMEDIA,KIRamDriveName);
+		}
+	__KTRACE_OPT(KBOOT,Kern::Printf("Registering IRAM drive - return %d",r));
+	return r;
+	}
+
+