// Copyright (c) 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:
// Class implementation of CDriveManager and CMassStorageDrive.
// 
//



/**
 @file
 @internalTechnology
*/

#include <f32fsys.h>
#include <e32property.h>


#include "usbmsshared.h"
#include "msctypes.h"

#include "drivepublisher.h"
#include "drivemanager.h"
#include "debug.h"
#include "msdebug.h"


void TMediaParams::Init(TLocalDriveCapsV4& aCaps)
    {
    iSize = aCaps.MediaSizeInBytes();
    TInt64 driveBlocks =  iSize / MAKE_TINT64(0, KDefaultBlockSize);
    iNumBlocks = I64LOW(driveBlocks);
    iMediaAtt = aCaps.iMediaAtt;
    }


void TLocalDriveRef::SetDriveState(TDriveState aState)
    {
    if (iDriveState != aState)
        {
        CMountCB* mount = iProxyDrive.Mount();
        __ASSERT_DEBUG(mount != NULL, User::Invariant());
        if (mount)
            {
            if (!IsActive(iDriveState) && IsActive(aState))
                {
                mount->IncLock();
                }
            else if (IsActive(iDriveState) && !IsActive(aState))
                {
                mount->DecLock();
                }
            __PRINT1(_L("SetDriveState: LockStatus=%d\n"), mount->LockStatus());
            }

        iDriveState = aState;
        iDriveStateChangedPublisher.DriveStateChanged();
        }
    }


TInt TLocalDriveRef::Read(const TInt64& aPos, TInt aLength, TDes8& aBuf, TBool aWholeMedia)
	{
    __MSFNLOG

	TInt err = KErrUnknown; // never return this

	if(aWholeMedia)
		{
		err = iProxyDrive.Read(aPos, aLength, &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
		}
	else
		{
		err = iProxyDrive.Read(aPos, aLength, aBuf);
		}

	if (err == KErrLocked)
		{
		SetDriveState(TLocalDriveRef::ELocked);
		}

	return err;
	}


TInt TLocalDriveRef::Write(const TInt64& aPos, TDesC8& aBuf, TBool aWholeMedia)
    {
	TInt err = KErrNone;

	TDriveState oldState = iDriveState;
	if (oldState != EActive)
        {
		// SCSI hasn't called SetCritical
		SetDriveState(EActive);
		}

	if (aWholeMedia)
		{
		err = iProxyDrive.Write(aPos, aBuf.Length(), &aBuf, KLocalMessageHandle, 0, RLocalDrive::ELocDrvWholeMedia);
		}
	else
		{
		err = iProxyDrive.Write(aPos,aBuf);
		}

	if (err == KErrLocked)
		{
		SetDriveState(ELocked);
		}
	else if (oldState != EActive)
		{
		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;
	if (aReset)
        {
	   	iMediaChanged = EFalse;
	   	}
	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;
    if (iDriveState == EMediaNotPresent)
		{
		err = KErrNotReady;
		}
	else
		{
        SetDriveState(aCritical ? EActive : EIdle);
		}
	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;
	buf.FillZ();

	__PRINT(_L("CMassStorageDrive::DoCaps calling Caps\n"));
	TInt err = iProxyDrive.Caps(buf);
	__PRINT1(_L("CMassStorageDrive::DoCaps: Caps returned %d\n"), err);

	if (err == KErrNone)
		{
		// Invoke function call operator to cast to TLocalDriveCapsV4&
		aInfo = buf();
		}

	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.
@post Object is fully constructed
 */
CMassStorageDrive* CMassStorageDrive::NewL(RCriticalSection& aCritSec,
                                           RDriveStateChangedPublisher& aDriveStateChangedPublisher)
    {
    __MSFNSLOG
	CMassStorageDrive* self = new (ELeave) CMassStorageDrive(aCritSec, aDriveStateChangedPublisher);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
    }


CMassStorageDrive::CMassStorageDrive(RCriticalSection& aCritSec,
									 RDriveStateChangedPublisher& aDriveStateChangedPublisher)
:   iCritSec(aCritSec),
	iMountState(EDisconnected),
	iDriveStateChangedPublisher(aDriveStateChangedPublisher)
	{
    __MSFNLOG
	}


void CMassStorageDrive::ConstructL()
    {
    __MSFNLOG
    iDriveMediaErrorPublisher = new (ELeave) RDriveMediaErrorPublisher();
    }


CMassStorageDrive::~CMassStorageDrive()
	{
    __MSFNLOG
    delete iDriveMediaErrorPublisher;
	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
	iCritSec.Wait();

	if(iMountState != EConnected)
		{
		err = KErrDisconnected;
		}
	else
		{
        err = iLocalDrive->Read(aPos, aLength, aBuf, aWholeMedia);
		}

	iCritSec.Signal();
	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();

	if (iMountState != EConnected)
		{
		err = KErrDisconnected;
		}
	else
		{
		__ASSERT_DEBUG(iLocalDrive, User::Invariant());
        err = iLocalDrive->Write(aPos, aBuf, aWholeMedia);
		}

	iCritSec.Signal();
	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;
	}


/**
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));
    // ignore leave
    err = err;
	return KErrAbort;
	}


TInt CMassStorageDrive::ClearCriticalError()
	{
    __MSFNLOG
	TRAPD(err, iDriveMediaErrorPublisher->PublishErrorL(EFalse));
    // ignore leave
    err = err;
	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();

	TBool mediaChanged = EFalse;
	if (iLocalDrive)
		{
		mediaChanged = iLocalDrive->IsMediaChanged(aReset);
        }

	iCritSec.Signal();

	__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();
	if (iLocalDrive)
		{
        err = iLocalDrive->SetCritical(aCritical);
		}

	iCritSec.Signal();
	return err;
	}

/**
Set the mount state
*/
void CMassStorageDrive::SetMountConnectedL(CProxyDrive& aProxyDrive,
                                           TBool& aMediaChanged,
                                           RDriveStateChangedPublisher& aDriveStateChangedPublisher)
	{
    __MSFNLOG
	TLocalDriveRef* localDrive = NULL;

	__PRINT(_L("SetMountConnectedL entering critical section\n"));
	iCritSec.Wait(); // note: signalled in SetMountState

   	TRAPD(err, localDrive = new (ELeave) TLocalDriveRef(aProxyDrive,
                                                        aMediaChanged,
                                                        aDriveStateChangedPublisher));
   	if (err)
   		{
   		iCritSec.Signal();
   		User::Leave(err);
   		}
	iLocalDrive = localDrive;
	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)
		{
		__PRINT(_L("SetMountState: No change\n"));
		}
	else
		{
		// If called from SetMountConnected, already in critical section,
        // otherwise, must enter it here.
        if (!aCriticalSection)
            {
			iCritSec.Wait();
            }

		switch(aNewState)
			{
			case EDisconnected:
				delete iLocalDrive;
				iLocalDrive = NULL;
				break;

			case EConnected:
			case EDisconnecting:
			case EConnecting:
				// Do not change iLocalDrive for these state changes
				break;
			}

		iMountState = aNewState;
		__PRINT1(_L("SetMountState: state=%d\n"), iMountState);

		iDriveStateChangedPublisher.DriveStateChanged();
		iCritSec.Signal();
		__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;
	}

/**
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;
	iCritSec.Wait();

	if (iLocalDrive)
		{
		TInt err = KErrGeneral;
        TLocalDriveCapsV4 caps;

		FOREVER
			{
			// Initialise in case Caps() fails
			caps.iType = ::EMediaNotPresent;
			err = DoCaps(caps);

			__PRINTERR(_L("CheckDriveState: DoCaps err=%d\n"), err);
			if (err == KErrNotReady || (err == KErrNone && caps.iType == ::EMediaNotPresent))
				{
				__PRINT(_L("CheckDriveState: detected MediaNotPresent\n"));

				SetDriveState(TLocalDriveRef::EMediaNotPresent);

				if (HandleCriticalError() == KErrAbort)
					break;
				}
			else
				{
				ClearCriticalError();
				break;
				}
			}

		if (err == KErrNone && caps.iType != ::EMediaNotPresent)
			{
            iMediaParams.Init(caps);
            TLocalDriveRef::TDriveState driveState = TLocalDriveRef::EIdle;

			if (iLocalDrive->DriveState() == TLocalDriveRef::EMediaNotPresent)
				{
				__PRINT(_L("CheckDriveState: detected media inserted\n"));
				}
			else if (iLocalDrive->DriveState() == TLocalDriveRef::ELocked &&
					 !(caps.iMediaAtt & KMediaAttLocked))
				{
				__PRINT(_L("CheckDriveState: detected media unlocked\n"));
				}
			else if (caps.iMediaAtt & KMediaAttLocked)
				{
				__PRINT(_L("CheckDriveState: detected media locked\n"));
				driveState = TLocalDriveRef::ELocked;
				}
            SetDriveState(driveState);
			}

		// Get the current state
		state = iLocalDrive->DriveState();
		}

	iCritSec.Signal();

	return state;
	}


/**
@param aNewState
*/
void CMassStorageDrive::SetDriveState(TLocalDriveRef::TDriveState aNewState)
	{
    __MSFNLOG
	__ASSERT_DEBUG(aNewState == TLocalDriveRef::EIdle ||
                   (iMountState == EConnected && NULL != iLocalDrive) ||
                   (iMountState == EDisconnecting && NULL != iLocalDrive),
        User::Invariant());

	if (!iLocalDrive)
		{
		__PRINT(_L("SetDriveState: Drive not mounted.\n"));
		}
	else
		{
        iLocalDrive->SetDriveState(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.
*/
CDriveManager* CDriveManager::NewL(const TLunToDriveMap& aDriveMap)
	{
    __MSFNSLOG
	__PRINT1(_L("CDriveManager::NewL - %d drives\n"), aDriveMap.Count());

	CDriveManager* self = new (ELeave) CDriveManager(aDriveMap.Count() -1);
	CleanupStack::PushL(self);
	self->ConstructL(aDriveMap);
	CleanupStack::Pop();
	return self;
	}

CDriveManager::CDriveManager(TLun aMaxLun)
:   iMaxLun(aMaxLun)
	{
    __MSFNLOG
    }

/**
Construct a CDriveManager object.
*/
void CDriveManager::ConstructL(const TLunToDriveMap& aDriveMap)
	{
    __MSFNLOG
	User::LeaveIfError(iDriveCritSec.CreateLocal());

    iDriveStateChangedPublisher = new (ELeave) RDriveStateChangedPublisher(iDrives, aDriveMap);

    iDrives.Reserve(iMaxLun + 1);

	for (TLun lun = 0; lun < iMaxLun + 1; lun++)
		{
		iDrives.Append(CMassStorageDrive::NewL(iDriveCritSec,
                                               *iDriveStateChangedPublisher));
		}

	// Publish initial drive state
	if (iDrives.Count() > 0)
		{
		iDriveStateChangedPublisher->DriveStateChanged();
		}
	}

/**
Destructor
*/
CDriveManager::~CDriveManager()
	{
    __MSFNLOG
	iDrives.ResetAndDestroy();
	delete iDriveStateChangedPublisher;
	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
@param aLun The Logical Drive Unit identifier (0..numDrives-1)
@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);
	CMassStorageDrive* drive = Drive(aLun);
	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();
	}

/**
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());
    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);
	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

	TLun i = aLun;
	TLun cnt = aLun + 1;

	if (aLun == KAllLuns)
		{
		i = 0;
		cnt = iMaxLun + 1;
		}

	for(; i < cnt; i++)
		{
		CMassStorageDrive* drive = Drive(i);
		err = drive->SetCritical(aCritical);
		}
	return err;
	}

void CDriveManager::Connect()
	{
	__FNLOG("CDriveManager::Connect");
    TLun lun = iMaxLun;
    do
        {
        Connect(lun);
        }
    while(--lun >= 0);
    }

/**
Inititiate transition to Connected.
@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);

	__PRINT2(_L("CDriveManager::Connect lun=%d, mountState=%d\n"), aLun, drive->MountState());

   	switch(drive->MountState())
   		{
 	case CMassStorageDrive::EDisconnected:
 		drive->SetMountConnecting();
 		break;
 	case CMassStorageDrive::EDisconnecting:
 		drive->SetMountConnected();
 		break;
 	case CMassStorageDrive::EConnected:
 	case CMassStorageDrive::EConnecting:
    default:
 		// do nothing
 		break;
		}
	}

void CDriveManager::Disconnect()
	{
	__FNLOG("CDriveManager::Disconnect");
    TLun lun = iMaxLun;
    do
        {
        Disconnect(lun);
        }
    while(--lun >= 0);
    }

/**
Inititiate transition 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 or Disconnecting.
*/
void CDriveManager::Disconnect(TLun aLun)
	{
    __MSFNLOG
	CMassStorageDrive* drive = Drive(aLun);
   	switch (drive->MountState())
   		{
   	case CMassStorageDrive::EConnected:
   		drive->SetMountDisconnecting();
   		break;
   	case CMassStorageDrive::EConnecting:
   		drive->SetMountDisconnected();
   		break;
   	case CMassStorageDrive::EDisconnected:
   	case CMassStorageDrive::EDisconnecting:
   		// do nothing
   		break;
   		}
	}