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