FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/shostmassstorage/testclient/usbtestmsclient/drivemanager.cpp

equal deleted inserted replaced

-:0659d0e1a03c
+:1d28c8722707
-// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2009-2010 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".
 //
 // Contributors:
 //
 // Description:
 // Class implementation of CDriveManager and CMassStorageDrive.
 //
 //
 /**
 #include "msctypes.h"
 #include "drivepublisher.h"
 #include "drivemanager.h"
 #include "debug.h"
-#include "msdebug.h"
 void TMediaParams::Init(TLocalDriveCapsV4& aCaps)
 {
 iSize = aCaps.MediaSizeInBytes();
 }
 }
 TInt TLocalDriveRef::Read(const TInt64& aPos, TInt aLength, TDes8& aBuf, TBool aWholeMedia)
-	{
+{
-__MSFNLOG
+TInt err = KErrUnknown; // never return this
-	TInt err = KErrUnknown; // never return this
+if(aWholeMedia)
+{
-	if(aWholeMedia)
+err = iProxyDrive.Read(aPos, aLength, &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
-		{
+}
-		err = iProxyDrive.Read(aPos, aLength, &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
+else
-		}
+{
-	else
+err = iProxyDrive.Read(aPos, aLength, aBuf);
-		{
+}
-		err = iProxyDrive.Read(aPos, aLength, aBuf);
-		}
+if (err == KErrLocked)
+{
-	if (err == KErrLocked)
+SetDriveState(TLocalDriveRef::ELocked);
-		{
+}
-		SetDriveState(TLocalDriveRef::ELocked);
-		}
+return err;
+}
-	return err;
-	}
 TInt TLocalDriveRef::Write(const TInt64& aPos, TDesC8& aBuf, TBool aWholeMedia)
 {
-	TInt err = KErrNone;
+TInt err = KErrNone;
-	TDriveState oldState = iDriveState;
+TDriveState oldState = iDriveState;
-	if (oldState != EActive)
+if (oldState != EActive)
 {
-		// SCSI hasn't called SetCritical
+// SCSI hasn't called SetCritical
-		SetDriveState(EActive);
+SetDriveState(EActive);
-		}
+}
-	if (aWholeMedia)
+if (aWholeMedia)
-		{
+{
-		err = iProxyDrive.Write(aPos, aBuf.Length(), &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
+err = iProxyDrive.Write(aPos, aBuf.Length(), &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
-		}
+}
-	else
+else
-		{
+{
-		err = iProxyDrive.Write(aPos,aBuf);
+err = iProxyDrive.Write(aPos,aBuf);
-		}
+}
-	if (err == KErrLocked)
+if (err == KErrLocked)
-		{
+{
-		SetDriveState(ELocked);
+SetDriveState(ELocked);
-		}
+}
-	else if (oldState != EActive)
+else if (oldState != EActive)
-		{
+{
-		SetDriveState(oldState);
+SetDriveState(oldState);
-		}
+}
 return err;
 }
 /**
 Checks the Media Changed flag, and optionally resets it.
 @return The state of the Media Changed flag.
 @param aReset If true, the Media Changed flag is reset to EFalse.
 */
 TBool TLocalDriveRef::IsMediaChanged(TBool aReset)
-	{
+{
-__MSFNLOG
+TBool mediaChanged = iMediaChanged;
-	TBool mediaChanged = iMediaChanged;
+if (aReset)
-	if (aReset)
+{
-{
+iMediaChanged = EFalse;
-	   	iMediaChanged = EFalse;
+}
-	   	}
+return mediaChanged;
-	return mediaChanged;
+}
-	}
 /**
 Set the Drive State to Active or Idle.
 @return KErrNone on success, KErrNotReady if media not present, KErrDisMounted if not mounted
 @param aCritical ETrue for Active, EFalse for Idle
 */
 TInt TLocalDriveRef::SetCritical(TBool aCritical)
-	{
+{
-__MSFNLOG
+TInt err = KErrNone;
-	TInt err = KErrNone;
 if (iDriveState == EMediaNotPresent)
-		{
+{
-		err = KErrNotReady;
+err = KErrNotReady;
-		}
+}
-	else
+else
-		{
+{
 SetDriveState(aCritical ? EActive : EIdle);
-		}
+}
-	return err;
+return err;
-	}
+}
 /**
 Provides an interface to CProxyDrive::Caps that hides the
 package buffer.
 @return KErrNone on success, otherwise system wide error code
 @param aInfo
 */
 TInt TLocalDriveRef::Caps(TLocalDriveCapsV4& aInfo)
-	{
+{
-__MSFNLOG
+TLocalDriveCapsV4Buf buf;
-	TLocalDriveCapsV4Buf buf;
+buf.FillZ();
-	buf.FillZ();
+__PRINT(_L("CMassStorageDrive::DoCaps calling Caps\n"));
-	__PRINT(_L("CMassStorageDrive::DoCaps calling Caps\n"));
+TInt err = iProxyDrive.Caps(buf);
-	TInt err = iProxyDrive.Caps(buf);
+__PRINT1(_L("CMassStorageDrive::DoCaps: Caps returned %d\n"), err);
-	__PRINT1(_L("CMassStorageDrive::DoCaps: Caps returned %d\n"), err);
+if (err == KErrNone)
-	if (err == KErrNone)
+{
-		{
+// Invoke function call operator to cast to TLocalDriveCapsV4&
-		// Invoke function call operator to cast to TLocalDriveCapsV4&
+aInfo = buf();
-		aInfo = buf();
+}
-		}
+return err;
-	return err;
+}
-	}
 ///////////////////////////////////////////////////////////////////////////////
 /**
 @param aCritSec A Critical Section object shared by all drives.
 @param aDrives Reference to the list of CMassStorageDrive objects.
 @param aDriveMap Reference to array mapping lun to drive number for supported
-	   mass storage drives.
+mass storage drives.
 @post Object is fully constructed
 */
 CMassStorageDrive* CMassStorageDrive::NewL(RCriticalSection& aCritSec,
 RDriveStateChangedPublisher& aDriveStateChangedPublisher)
 {
-__MSFNSLOG
+CMassStorageDrive* self = new (ELeave) CMassStorageDrive(aCritSec, aDriveStateChangedPublisher);
-	CMassStorageDrive* self = new (ELeave) CMassStorageDrive(aCritSec, aDriveStateChangedPublisher);
+CleanupStack::PushL(self);
-	CleanupStack::PushL(self);
+self->ConstructL();
-	self->ConstructL();
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return self;
-	return self;
 }
 CMassStorageDrive::CMassStorageDrive(RCriticalSection& aCritSec,
-									 RDriveStateChangedPublisher& aDriveStateChangedPublisher)
+RDriveStateChangedPublisher& aDriveStateChangedPublisher)
 :   iCritSec(aCritSec),
-	iMountState(EDisconnected),
+iMountState(EDisconnected),
-	iDriveStateChangedPublisher(aDriveStateChangedPublisher)
+iDriveStateChangedPublisher(aDriveStateChangedPublisher)
-	{
+{
-__MSFNLOG
+}
-	}
 void CMassStorageDrive::ConstructL()
 {
-__MSFNLOG
 iDriveMediaErrorPublisher = new (ELeave) RDriveMediaErrorPublisher();
 }
 CMassStorageDrive::~CMassStorageDrive()
-	{
+{
-__MSFNLOG
 delete iDriveMediaErrorPublisher;
-	delete iLocalDrive;
+delete iLocalDrive;
-	}
+}
 /**
 Read from the target drive unit.
 @return KErrNone on success, otherwise system wide error code
 */
 TInt CMassStorageDrive::Read(const TInt64& aPos, TInt aLength, TDes8& aBuf, TBool aWholeMedia)
-	{
+{
-__MSFNLOG
+TInt err = KErrUnknown; // never return this
-	TInt err = KErrUnknown; // never return this
+iCritSec.Wait();
-	iCritSec.Wait();
+if(iMountState != EConnected)
-	if(iMountState != EConnected)
+{
-		{
+err = KErrDisconnected;
-		err = KErrDisconnected;
+}
-		}
+else
-	else
+{
-		{
 err = iLocalDrive->Read(aPos, aLength, aBuf, aWholeMedia);
-		}
+}
-	iCritSec.Signal();
+iCritSec.Signal();
-	return err;
+return err;
-	}
+}
 /**
 Write to the target drive unit.
 @return KErrNone on success, otherwise system wide error code
 */
 TInt CMassStorageDrive::Write(const TInt64& aPos, TDesC8& aBuf, TBool aWholeMedia)
-	{
+{
-__MSFNLOG
+TInt err = KErrNone;
+iCritSec.Wait();
-	TInt err = KErrNone;
-	iCritSec.Wait();
+if (iMountState != EConnected)
+{
-	if (iMountState != EConnected)
+err = KErrDisconnected;
-		{
+}
-		err = KErrDisconnected;
+else
-		}
+{
-	else
+__ASSERT_DEBUG(iLocalDrive, User::Invariant());
-		{
-		__ASSERT_DEBUG(iLocalDrive, User::Invariant());
 err = iLocalDrive->Write(aPos, aBuf, aWholeMedia);
-		}
+}
-	iCritSec.Signal();
+iCritSec.Signal();
-	return err;
+return err;
-	}
+}
 /**
 Provides an interface to CProxyDrive::Caps that hides the
 package buffer.
 @return KErrNone on success, otherwise system wide error code
 @param aInfo
 */
 TInt CMassStorageDrive::DoCaps(TLocalDriveCapsV4& aInfo)
-	{
+{
-__MSFNLOG
 TInt err = KErrDisMounted;
 if (iLocalDrive)
 {
 err = iLocalDrive->Caps(aInfo);
 }
-	return err;
+return err;
-	}
+}
 /**
 Publish media error, user should reinsert the memory card.
 Similar to FAT32's TDriver::HandleCriticalError.
 Note: User notification is not implemented, instead we abort and dismount.
 */
 TInt CMassStorageDrive::HandleCriticalError()
-	{
+{
-__MSFNLOG
+TRAPD(err, iDriveMediaErrorPublisher->PublishErrorL(ETrue));
-	TRAPD(err, iDriveMediaErrorPublisher->PublishErrorL(ETrue));
 // ignore leave
 err = err;
-	return KErrAbort;
+return KErrAbort;
-	}
+}
 TInt CMassStorageDrive::ClearCriticalError()
-	{
+{
-__MSFNLOG
+TRAPD(err, iDriveMediaErrorPublisher->PublishErrorL(EFalse));
-	TRAPD(err, iDriveMediaErrorPublisher->PublishErrorL(EFalse));
 // ignore leave
 err = err;
-	return KErrNone;
+return KErrNone;
-	}
+}
 /**
 Checks the Media Changed flag, and optionally resets it.
 @return The state of the Media Changed flag.
 @param aReset If true, the Media Changed flag is reset to EFalse.
 */
 TBool CMassStorageDrive::IsMediaChanged(TBool aReset)
-	{
+{
-__MSFNLOG
+iCritSec.Wait();
-	iCritSec.Wait();
+TBool mediaChanged = EFalse;
+if (iLocalDrive)
-	TBool mediaChanged = EFalse;
+{
-	if (iLocalDrive)
+mediaChanged = iLocalDrive->IsMediaChanged(aReset);
-		{
+}
-		mediaChanged = iLocalDrive->IsMediaChanged(aReset);
-}
+iCritSec.Signal();
-	iCritSec.Signal();
+__PRINT1(_L("CMassStorageDrive::IsMediaChanged: returning %d\n"), mediaChanged);
+return mediaChanged;
-	__PRINT1(_L("CMassStorageDrive::IsMediaChanged: returning %d\n"), mediaChanged);
+}
-	return mediaChanged;
-	}
 /**
 Set the Drive State to Active or Idle.
 @return KErrNone on success, KErrNotReady if media not present, KErrDisMounted if not mounted
 @param aCritical ETrue for Active, EFalse for Idle
 */
 TInt CMassStorageDrive::SetCritical(TBool aCritical)
-	{
+{
-__MSFNLOG
+TInt err = KErrDisMounted;
+iCritSec.Wait();
-	TInt err = KErrDisMounted;
+if (iLocalDrive)
-	iCritSec.Wait();
+{
-	if (iLocalDrive)
-		{
 err = iLocalDrive->SetCritical(aCritical);
-		}
+}
-	iCritSec.Signal();
+iCritSec.Signal();
-	return err;
+return err;
-	}
+}
 /**
 Set the mount state
 */
 void CMassStorageDrive::SetMountConnectedL(CProxyDrive& aProxyDrive,
 TBool& aMediaChanged,
 RDriveStateChangedPublisher& aDriveStateChangedPublisher)
-	{
+{
-__MSFNLOG
+TLocalDriveRef* localDrive = NULL;
-	TLocalDriveRef* localDrive = NULL;
+__PRINT(_L("SetMountConnectedL entering critical section\n"));
-	__PRINT(_L("SetMountConnectedL entering critical section\n"));
+iCritSec.Wait(); // note: signalled in SetMountState
-	iCritSec.Wait(); // note: signalled in SetMountState
+TRAPD(err, localDrive = new (ELeave) TLocalDriveRef(aProxyDrive,
-	TRAPD(err, localDrive = new (ELeave) TLocalDriveRef(aProxyDrive,
 aMediaChanged,
 aDriveStateChangedPublisher));
-	if (err)
+if (err)
-		{
+{
-		iCritSec.Signal();
+iCritSec.Signal();
-		User::Leave(err);
+User::Leave(err);
-		}
+}
-	iLocalDrive = localDrive;
+iLocalDrive = localDrive;
-	SetMountState(EConnected, ETrue);
+SetMountState(EConnected, ETrue);
-	}
+}
 /**
 @return KErrNone
 @param aNewState
 @param aLocalDrive Only provide this if aNewState is EConnected.
 */
 void CMassStorageDrive::SetMountState(TMountState aNewState, TBool aCriticalSection/*=EFalse*/)
-	{
+{
-__MSFNLOG
+if(iMountState == aNewState)
-	if(iMountState == aNewState)
+{
-		{
+__PRINT(_L("SetMountState: No change\n"));
-		__PRINT(_L("SetMountState: No change\n"));
+}
-		}
+else
-	else
+{
-		{
+// If called from SetMountConnected, already in critical section,
-		// If called from SetMountConnected, already in critical section,
 // otherwise, must enter it here.
 if (!aCriticalSection)
 {
-			iCritSec.Wait();
+iCritSec.Wait();
 }
-		switch(aNewState)
+switch(aNewState)
-			{
+{
-			case EDisconnected:
+case EDisconnected:
-				delete iLocalDrive;
+delete iLocalDrive;
-				iLocalDrive = NULL;
+iLocalDrive = NULL;
-				break;
+break;
-			case EConnected:
+case EConnected:
-			case EDisconnecting:
+case EDisconnecting:
-			case EConnecting:
+case EConnecting:
-				// Do not change iLocalDrive for these state changes
+// Do not change iLocalDrive for these state changes
-				break;
+break;
-			}
+}
-		iMountState = aNewState;
+iMountState = aNewState;
-		__PRINT1(_L("SetMountState: state=%d\n"), iMountState);
+__PRINT1(_L("SetMountState: state=%d\n"), iMountState);
-		iDriveStateChangedPublisher.DriveStateChanged();
+iDriveStateChangedPublisher.DriveStateChanged();
-		iCritSec.Signal();
+iCritSec.Signal();
-		__PRINT(_L("SetMountState has left the critical section\n"));
+__PRINT(_L("SetMountState has left the critical section\n"));
-		}
+}
-	}
+}
 /**
 @return Current drive media state
 */
 TLocalDriveRef::TDriveState CMassStorageDrive::DriveState() const
-	{
+{
-__MSFNSLOG
+return iLocalDrive ? iLocalDrive->DriveState() : TLocalDriveRef::EErrDisMounted;
-	return iLocalDrive ? iLocalDrive->DriveState() : TLocalDriveRef::EErrDisMounted;
+}
-	}
 /**
 Check for media not present, and return the drive state.
 @return Current drive media state
 */
 TLocalDriveRef::TDriveState CMassStorageDrive::CheckDriveState()
-	{
+{
-__MSFNLOG
+TLocalDriveRef::TDriveState state = TLocalDriveRef::EErrDisMounted;
-	TLocalDriveRef::TDriveState state = TLocalDriveRef::EErrDisMounted;
+iCritSec.Wait();
-	iCritSec.Wait();
+if (iLocalDrive)
-	if (iLocalDrive)
+{
-		{
+TInt err = KErrGeneral;
-		TInt err = KErrGeneral;
 TLocalDriveCapsV4 caps;
-		FOREVER
+FOREVER
-			{
+{
-			// Initialise in case Caps() fails
+// Initialise in case Caps() fails
-			caps.iType = ::EMediaNotPresent;
+caps.iType = ::EMediaNotPresent;
-			err = DoCaps(caps);
+err = DoCaps(caps);
-			__PRINTERR(_L("CheckDriveState: DoCaps err=%d\n"), err);
+__PRINTERR(_L("CheckDriveState: DoCaps err=%d\n"), err);
-			if (err == KErrNotReady || (err == KErrNone && caps.iType == ::EMediaNotPresent))
+if (err == KErrNotReady || (err == KErrNone && caps.iType == ::EMediaNotPresent))
-				{
+{
-				__PRINT(_L("CheckDriveState: detected MediaNotPresent\n"));
+__PRINT(_L("CheckDriveState: detected MediaNotPresent\n"));
-				SetDriveState(TLocalDriveRef::EMediaNotPresent);
+SetDriveState(TLocalDriveRef::EMediaNotPresent);
-				if (HandleCriticalError() == KErrAbort)
+if (HandleCriticalError() == KErrAbort)
-					break;
+break;
-				}
+}
-			else
+else
-				{
+{
-				ClearCriticalError();
+ClearCriticalError();
-				break;
+break;
-				}
+}
-			}
+}
-		if (err == KErrNone && caps.iType != ::EMediaNotPresent)
+if (err == KErrNone && caps.iType != ::EMediaNotPresent)
-			{
+{
 iMediaParams.Init(caps);
 TLocalDriveRef::TDriveState driveState = TLocalDriveRef::EIdle;
-			if (iLocalDrive->DriveState() == TLocalDriveRef::EMediaNotPresent)
+if (iLocalDrive->DriveState() == TLocalDriveRef::EMediaNotPresent)
-				{
+{
-				__PRINT(_L("CheckDriveState: detected media inserted\n"));
+__PRINT(_L("CheckDriveState: detected media inserted\n"));
-				}
+}
-			else if (iLocalDrive->DriveState() == TLocalDriveRef::ELocked &&
+else if (iLocalDrive->DriveState() == TLocalDriveRef::ELocked &&
-					 !(caps.iMediaAtt & KMediaAttLocked))
+!(caps.iMediaAtt & KMediaAttLocked))
-				{
+{
-				__PRINT(_L("CheckDriveState: detected media unlocked\n"));
+__PRINT(_L("CheckDriveState: detected media unlocked\n"));
-				}
+}
-			else if (caps.iMediaAtt & KMediaAttLocked)
+else if (caps.iMediaAtt & KMediaAttLocked)
-				{
+{
-				__PRINT(_L("CheckDriveState: detected media locked\n"));
+__PRINT(_L("CheckDriveState: detected media locked\n"));
-				driveState = TLocalDriveRef::ELocked;
+driveState = TLocalDriveRef::ELocked;
-				}
+}
 SetDriveState(driveState);
-			}
+}
-		// Get the current state
+// Get the current state
-		state = iLocalDrive->DriveState();
+state = iLocalDrive->DriveState();
-		}
+}
-	iCritSec.Signal();
+iCritSec.Signal();
-	return state;
+return state;
-	}
+}
 /**
 @param aNewState
 */
 void CMassStorageDrive::SetDriveState(TLocalDriveRef::TDriveState aNewState)
-	{
+{
-__MSFNLOG
+__ASSERT_DEBUG(aNewState == TLocalDriveRef::EIdle ||
-	__ASSERT_DEBUG(aNewState == TLocalDriveRef::EIdle ||
 (iMountState == EConnected && NULL != iLocalDrive) ||
 (iMountState == EDisconnecting && NULL != iLocalDrive),
 User::Invariant());
-	if (!iLocalDrive)
+if (!iLocalDrive)
-		{
+{
-		__PRINT(_L("SetDriveState: Drive not mounted.\n"));
+__PRINT(_L("SetDriveState: Drive not mounted.\n"));
-		}
+}
-	else
+else
-		{
+{
 iLocalDrive->SetDriveState(aNewState);
-		__PRINT2(_L("SetDriveState: %d->%d\n"), iLocalDrive->iDriveState, aNewState);
+__PRINT2(_L("SetDriveState: %d->%d\n"), iLocalDrive->iDriveState, aNewState);
-		}
+}
-	}
+}
 /////////////////////////////////////////////////////////////////
 /**
 Construct a CDriveManager object.
 @param aDriveMap Reference to array mapping lun to drive number for supported
-	   mass storage drives.
+mass storage drives.
 */
 CDriveManager* CDriveManager::NewL(const TLunToDriveMap& aDriveMap)
-	{
+{
-__MSFNSLOG
+__PRINT1(_L("CDriveManager::NewL - %d drives\n"), aDriveMap.Count());
-	__PRINT1(_L("CDriveManager::NewL - %d drives\n"), aDriveMap.Count());
+CDriveManager* self = new (ELeave) CDriveManager(aDriveMap.Count() -1);
-	CDriveManager* self = new (ELeave) CDriveManager(aDriveMap.Count() -1);
+CleanupStack::PushL(self);
-	CleanupStack::PushL(self);
+self->ConstructL(aDriveMap);
-	self->ConstructL(aDriveMap);
+CleanupStack::Pop();
-	CleanupStack::Pop();
+return self;
-	return self;
+}
-	}
 CDriveManager::CDriveManager(TLun aMaxLun)
 :   iMaxLun(aMaxLun)
-	{
+{
-__MSFNLOG
 }
 /**
 Construct a CDriveManager object.
 */
 void CDriveManager::ConstructL(const TLunToDriveMap& aDriveMap)
-	{
+{
-__MSFNLOG
+User::LeaveIfError(iDriveCritSec.CreateLocal());
-	User::LeaveIfError(iDriveCritSec.CreateLocal());
 iDriveStateChangedPublisher = new (ELeave) RDriveStateChangedPublisher(iDrives, aDriveMap);
 iDrives.Reserve(iMaxLun + 1);
-	for (TLun lun = 0; lun < iMaxLun + 1; lun++)
+for (TLun lun = 0; lun < iMaxLun + 1; lun++)
-		{
+{
-		iDrives.Append(CMassStorageDrive::NewL(iDriveCritSec,
+iDrives.Append(CMassStorageDrive::NewL(iDriveCritSec,
 *iDriveStateChangedPublisher));
-		}
+}
-	// Publish initial drive state
+// Publish initial drive state
-	if (iDrives.Count() > 0)
+if (iDrives.Count() > 0)
-		{
+{
-		iDriveStateChangedPublisher->DriveStateChanged();
+iDriveStateChangedPublisher->DriveStateChanged();
-		}
+}
-	}
+}
 /**
 Destructor
 */
 CDriveManager::~CDriveManager()
-	{
+{
-__MSFNLOG
+iDrives.ResetAndDestroy();
-	iDrives.ResetAndDestroy();
+delete iDriveStateChangedPublisher;
-	delete iDriveStateChangedPublisher;
+iDriveCritSec.Close();
-	iDriveCritSec.Close();
+}
-	}
 /**
 Set the mount state to Connected and specify the Proxy Drive.
 @return KErrNone on success, otherwise system wide error code
 @param aDrive The mounted Proxy Drive
 @pre If the Mount State is Connected, then aDrive must be the
 same as it was the last time this function was called.
 @post The Mount State will be Connected.
 */
 void CDriveManager::RegisterDriveL(CProxyDrive& aProxyDrive, TBool& aMediaChanged, TLun aLun)
-	{
+{
-__MSFNLOG
+__PRINT1(_L("Lun=%d \n"),aLun);
-	__PRINT1(_L("Lun=%d \n"),aLun);
+CMassStorageDrive* drive = Drive(aLun);
-	CMassStorageDrive* drive = Drive(aLun);
+drive->SetMountConnectedL(aProxyDrive, aMediaChanged, *iDriveStateChangedPublisher);
-	drive->SetMountConnectedL(aProxyDrive, aMediaChanged, *iDriveStateChangedPublisher);
+}
-	}
 /**
 Set the mount state to Disconnected.
 @return KErrNone on success, otherwise system wide error code
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @post The Mount State will be Disconnected.
 */
 void CDriveManager::DeregisterDrive(TLun aLun)
-	{
+{
-__MSFNLOG
 CMassStorageDrive* drive = Drive(aLun);
-	drive->SetMountDisconnected();
+drive->SetMountDisconnected();
-	}
+}
 /**
 Return a pointer to the drive specified aLun, or NULL if aLun is invalid.
 @return Pointer to the specified drive, or NULL.
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @param aError KErrNone on success, KErrArgument if NULL is returned.
 */
 CMassStorageDrive* CDriveManager::Drive(TLun aLun) const
-	{
+{
-__MSFNSLOG
+__ASSERT_DEBUG(aLun < iDrives.Count(), User::Invariant());
-	__ASSERT_DEBUG(aLun < iDrives.Count(), User::Invariant());
 return iDrives[aLun];
-	}
+}
 /**
 Checks the Media Changed flag, and optionally resets it.
 @return The state of the Media Changed flag.
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @param aReset If true, the Media Changed flag is reset to EFalse.
 */
 TBool CDriveManager::IsMediaChanged(TLun aLun, TBool aReset)
-	{
+{
-__MSFNLOG
+CMassStorageDrive* drive = Drive(aLun);
-	CMassStorageDrive* drive = Drive(aLun);
+return drive->IsMediaChanged(aReset);
-	return drive->IsMediaChanged(aReset);
+}
-	}
 /**
 Set the Drive State to Active or Idle.
 Ref: 3.6.3.2 - PREVENT_MEDIUM_REMOVAL
 @return KErrNone on success, otherwise system wide error code
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @param aCritical ETrue for Active, EFalse for Idle
 */
 TInt CDriveManager::SetCritical(TLun aLun, TBool aCritical)
-	{
+{
-__MSFNLOG
+TInt err = KErrUnknown; // never return this
-	TInt err = KErrUnknown; // never return this
+TLun i = aLun;
-	TLun i = aLun;
+TLun cnt = aLun + 1;
-	TLun cnt = aLun + 1;
+if (aLun == KAllLuns)
-	if (aLun == KAllLuns)
+{
-		{
+i = 0;
-		i = 0;
+cnt = iMaxLun + 1;
-		cnt = iMaxLun + 1;
+}
-		}
+for(; i < cnt; i++)
-	for(; i < cnt; i++)
+{
-		{
+CMassStorageDrive* drive = Drive(i);
-		CMassStorageDrive* drive = Drive(i);
+err = drive->SetCritical(aCritical);
-		err = drive->SetCritical(aCritical);
+}
-		}
+return err;
-	return err;
+}
-	}
 void CDriveManager::Connect()
-	{
+{
-	__FNLOG("CDriveManager::Connect");
 TLun lun = iMaxLun;
 do
 {
 Connect(lun);
 }
 @return KErrNone on success, otherwise system wide error code
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @post The Mount State will be Connected or Connecting.
 */
 void CDriveManager::Connect(TLun aLun)
-	{
+{
-__MSFNLOG
+CMassStorageDrive* drive = Drive(aLun);
-	CMassStorageDrive* drive = Drive(aLun);
+__PRINT2(_L("CDriveManager::Connect lun=%d, mountState=%d\n"), aLun, drive->MountState());
-	__PRINT2(_L("CDriveManager::Connect lun=%d, mountState=%d\n"), aLun, drive->MountState());
+switch(drive->MountState())
-	switch(drive->MountState())
+{
-		{
+case CMassStorageDrive::EDisconnected:
-	case CMassStorageDrive::EDisconnected:
+drive->SetMountConnecting();
-		drive->SetMountConnecting();
+break;
-		break;
+case CMassStorageDrive::EDisconnecting:
-	case CMassStorageDrive::EDisconnecting:
+drive->SetMountConnected();
-		drive->SetMountConnected();
+break;
-		break;
+case CMassStorageDrive::EConnected:
-	case CMassStorageDrive::EConnected:
+case CMassStorageDrive::EConnecting:
-	case CMassStorageDrive::EConnecting:
 default:
-		// do nothing
+// do nothing
-		break;
+break;
-		}
+}
-	}
+}
 void CDriveManager::Disconnect()
-	{
+{
-	__FNLOG("CDriveManager::Disconnect");
 TLun lun = iMaxLun;
 do
 {
 Disconnect(lun);
 }
 @return KErrNone on success, otherwise system wide error code
 @param aLun The Logical Drive Unit identifier (0..numDrives-1)
 @post The Mount State will be Disconnected or Disconnecting.
 */
 void CDriveManager::Disconnect(TLun aLun)
-	{
+{
-__MSFNLOG
+CMassStorageDrive* drive = Drive(aLun);
-	CMassStorageDrive* drive = Drive(aLun);
+switch (drive->MountState())
-	switch (drive->MountState())
+{
-		{
+case CMassStorageDrive::EConnected:
-	case CMassStorageDrive::EConnected:
+drive->SetMountDisconnecting();
-		drive->SetMountDisconnecting();
+break;
-		break;
+case CMassStorageDrive::EConnecting:
-	case CMassStorageDrive::EConnecting:
+drive->SetMountDisconnected();
-		drive->SetMountDisconnected();
+break;
-		break;
+case CMassStorageDrive::EDisconnected:
-	case CMassStorageDrive::EDisconnected:
+case CMassStorageDrive::EDisconnecting:
-	case CMassStorageDrive::EDisconnecting:
+// do nothing
-		// do nothing
+break;
-		break;
+}
-		}
+}
-	}

changeset 300	1d28c8722707
parent 0	a41df078684a