/*

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

*

*/

//

// hostusbmsproxy.cpp

//

// This file system extension provides a way to access a drive on the MS system in "raw format".

// It can be used to test large files / drives

//

/** @file

@internalTechnology

*/

#include <f32fsys.h>

#include "hostusbmsproxy.h"

#include "debug.h"

CUsbHostMsProxyDrive::CUsbHostMsProxyDrive(CMountCB* aMount, CExtProxyDriveFactory* aDevice)

:   CExtProxyDrive(aMount,aDevice)

	{

	__MSFNSLOG

	}

CUsbHostMsProxyDrive::~CUsbHostMsProxyDrive()

	{

	__MSFNSLOG

	iUsbHostMsLun.UnInitialise();

	}

TInt CUsbHostMsProxyDrive::InitialiseOffset(TCapsInfo& aCapsInfo)

	{

	__MSFNSLOG

    const TInt KPartitionInfoSize = TMsDataMemMap::KSectorSize;

	TBuf8<KPartitionInfoSize> partitionInfo;

	TInt r;

	r = iUsbHostMsLun.Read(0 , KPartitionInfoSize, (TDes8 &) partitionInfo);

	if (r != KErrNone)

        {

		__PXYPRINT1(_L("!! Reading medium failed with %d !!"), r);

		return r;

        }

	TUint8 *iIntBuf = (TUint8 *) partitionInfo.Ptr();

	// Read of the first sector successful so check for a Master Boot Record

	if (*(TUint16*)(&iIntBuf[KMBRSignatureOffset])!= KMBRSignature)

		{

		__PXYPRINT(_L("MBR not present"));

        iMsDataMemMap.Reset();

        }

	else

		{

		// Move the partition entries to a 4 byte boundary

		memcpy(&iIntBuf[0],&iIntBuf[KMBRFirstPartitionOffset],(sizeof(TMBRPartitionEntry)<<2));

		// Search for a x86 default boot partition - let this be the first

		TMBRPartitionEntry* pe = (TMBRPartitionEntry*)(&iIntBuf[0]);

		TInt firstValidPartitionCount = -1;

		TInt defaultPartitionNumber = -1;

		TInt partitionCount = 0;

		for (TInt i = 0; i < KMBRMaxPrimaryPartitions; i++, pe++)

			{

			if (pe->IsValidDosPartition() || pe->IsValidFAT32Partition())

				{

				__PXYPRINT(_L("Found a Valid Partition"));

				partitionCount++;

				if (firstValidPartitionCount < 0)

					firstValidPartitionCount = i;

				if (pe->iX86BootIndicator == KBootIndicatorBootable)

                    {

					defaultPartitionNumber = i;

					break;

                    }

				}

			else

				{

				__PXYPRINT(_L("!! Invalid Partition !!"));

				}

			}

		// Check the validity of the partition address boundaries

	    if (partitionCount > 0)

		    {

            __PXYPRINT1(_L("Using Partition %d"), partitionCount);

			pe = (TMBRPartitionEntry*)(&iIntBuf[0]);

            TInt partitionIndex = firstValidPartitionCount;

            if (defaultPartitionNumber > 0)

                {

                partitionIndex = defaultPartitionNumber;

                }

            TMBRPartitionEntry& partitionEntry = pe[partitionIndex];

			iMsDataMemMap.InitDataArea(partitionEntry.iFirstSector,

                                       partitionEntry.iNumSectors);

			__PXYPRINT2(_L("paritioncount = %d defaultpartition = %d"),

						partitionCount, partitionIndex);

			__PXYPRINT2(_L("iFirstSector = x%x iNumSectors = x%x"),

						partitionEntry.iFirstSector,

						partitionEntry.iNumSectors);

			}

		else

			{

            __PXYPRINT(_L("No partition found"));

			iMsDataMemMap.InitDataArea(0, aCapsInfo.iNumberOfBlocks);

			__PXYPRINT2(_L("iFirstSector = x%x iNumSectors = x%x"),

						0, aCapsInfo.iNumberOfBlocks);

			}

		}

	return KErrNone;

	}

/**

Initialise the proxy drive.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Initialise()

	{

	__MSFNSLOG

    __HOSTPRINT(_L(">>> CUsbHostMsProxyDrive::Initialise()"));

	if(Mount())

		{

		// as we can't currently handle remounting devices that have

		// been removed by unplugging the USB cable, disable critical notifiers

		// as there's no point in asking the user to re-insert the disk.

		Mount()->SetNotifyOff();

		}

    // Check for media presence

	TCapsInfo capsInfo;

	TInt err = iUsbHostMsLun.Caps(capsInfo);

    if (err == KErrNone)

        {

        err = InitialiseOffset(capsInfo);

        }

    __HOSTPRINT1(_L("<<< CUsbHostMsProxyDrive::Initialise() err = %d"), err);

    return err;

	}

TInt CUsbHostMsProxyDrive::SetInfo(const RMessage2 &msg, TAny* aMessageParam2, TAny* aMessageParam3)

    {

	__MSFNSLOG

    __HOSTPRINT(_L(">>> CUsbHostMsProxyDrive::SetInfo()"));

	TMassStorageUnitInfo iUnitInfo;

    TPckg<TMassStorageUnitInfo> infoPckg(iUnitInfo);

	TRAPD(err, msg.ReadL(2, infoPckg));

	if(err != KErrNone)

		{

		__PXYPRINT1(_L("Cant read from the RMessage %d"), err);

        __HOSTPRINT1(_L("<<< CUsbHostMsProxyDrive::SetInfo() err = %d"), err);

		return err;

		}

	err = iUsbHostMsLun.Initialise(msg, 3, iUnitInfo.iLunID);

	if(err != KErrNone)

		{

		__PXYPRINT1(_L("Initialising logical unit failed %d"), err);

        __HOSTPRINT1(_L("<<< CUsbHostMsProxyDrive::SetInfo() err = %d"), err);

		return err;

		}

    __HOSTPRINT1(_L("<<< CUsbHostMsProxyDrive::SetInfo() err = %d"), err);

	return err;

    }

TInt CUsbHostMsProxyDrive::Dismounted()

	{

	__MSFNSLOG

	return KErrNone;

	}

TInt CUsbHostMsProxyDrive::Enlarge(TInt /*aLength*/)

	{

	__MSFNSLOG

	return KErrNotSupported;

	}

TInt CUsbHostMsProxyDrive::ReduceSize(TInt /*aPos*/, TInt /*aLength*/)

	{

	__MSFNSLOG

	return KErrNotSupported;

	}

#define GetIndex(msg, aAddress, aIndex)			\

	aIndex = msg.Ptr0() == aAddress ? 0 :				\

				msg.Ptr1() == aAddress ? 1 :			\

					msg.Ptr1() == aAddress ? 2 :		\

						msg.Ptr1() == aAddress ? 3 : -1;

/**

Read from the proxy drive.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aTrg to read the data from.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Read(TInt64 aPos, TInt aLength,

                                const TAny* aTrg, TInt aThreadHandle, TInt aOffset)

	{

	__MSFNSLOG

    __HOSTPRINT4(_L("\n>>> HOST Read Pos=0x%lx LBA=0x%lx 0x%x 0x%x"),

                 aPos, aPos/KBlockSize, aLength, aOffset);

	TBool localMessage = (aThreadHandle == KLocalMessageHandle);

	//

	// Set file position to where we want to read...

	//

	if(!localMessage)

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		localMessage = (msg.Handle() == KLocalMessageHandle);

		}

	TInt index = 0;

	if (!localMessage)

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		GetIndex(msg, aTrg, index);

		if (index < 0)

            {

            __HOSTPRINT1(_L("<<< HOST Read ret=%d"), KErrArgument);

            return KErrArgument;

            }

		}

	/* Calculate the end position */

	TInt64 end = aPos + static_cast<TInt64>(aLength);

	/* check whether there is enough source data to write to the destination descriptor */

	TInt64 truncate;

	if(localMessage)

		{

		truncate = aLength - (((TPtr8* )aTrg)->MaxLength() - aOffset);

	    __PXYPRINT1(_L("Descriptor length: %08x"), ((TPtr8* )aTrg)->MaxLength());

		}

	else

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		truncate = aLength - (msg.GetDesMaxLength(index) - aOffset);

	    __PXYPRINT1(_L("Descriptor length: %08x"), msg.GetDesMaxLength(index));

		}

	__PXYPRINT1(_L("Offset: %08x"), aOffset);

	__PXYPRINT1(_L("Truncate: 0x%lx"), truncate);

	if (truncate > 0)

		{

		end -= truncate;

		}

	iBuf.SetMax();

    TInt r;

    TInt64 mediaPos;

	while (aPos < end)

        {

		TInt len = end - aPos;

        mediaPos = aPos;

        r = iMsDataMemMap.CheckBlockInRange(mediaPos, len);

        if (r != KErrNone)

            {

            __HOSTPRINT1(_L("<<< HOST Read ret=%d"), r);

            return r;

            }

		if (localMessage)

			{

			TPtr8* pTrgPtr = (TPtr8*)aTrg;

			TPtr8 trgDes((TUint8*)(pTrgPtr->MidTPtr(aOffset).Ptr()), pTrgPtr->MaxLength() - aOffset);

			r = iUsbHostMsLun.Read(mediaPos, len, trgDes);

			if (r != KErrNone)

				return r;

			pTrgPtr->SetLength(aOffset + trgDes.Length());

			}

		else

			{

			if (len > iBuf.MaxLength())

				len = iBuf.MaxLength();

            r = iUsbHostMsLun.Read(mediaPos, len, iBuf);

			if (r != KErrNone)

                {

                __HOSTPRINT1(_L("<<< HOST Read ret=%d"), r);

                return r;

                }

			iBuf.SetLength(len);

			RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

			r = msg.Write(index, iBuf, aOffset);

			if (r != KErrNone)

                {

                __HOSTPRINT1(_L("<<< HOST Read ret=%d"), r);

                return r;

                }

			}

        aPos += len;

        aOffset += len;

        }

    __HOSTPRINT1(_L("<<< HOST Read ret=%d"), KErrNone);

	return KErrNone;

	}

/**

Read from the proxy drive, and pass flags to driver.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aTrg to read the data from.

@param aFlags  Flags to be passed into the driver.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Read(TInt64 aPos, TInt aLength,

                                const TAny* aTrg, TInt aThreadHandle, TInt aOffset, TInt /* aFlags */)

	{

	__MSFNSLOG

	return Read(aPos, aLength, aTrg, aThreadHandle, aOffset);

	}

/**

Read from the proxy drive.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Read(TInt64 aPos, TInt aLength, TDes8& aTrg)

	{

	__MSFNSLOG

    __HOSTPRINT3(_L("\n>>> HOST Read Pos=0x%lx LBA=0x%lx 0x%x"),

                 aPos, aPos/KBlockSize, aLength);

	return iUsbHostMsLun.Read(iMsDataMemMap.GetDataPos(aPos), aLength, aTrg);

	}

/**

Write to the proxy drive.

@param aPos    The address from where the write begins.

@param aLength The length of the write.

@param aSrc    A descriptor of the memory buffer from which to write.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aSrc to write the data to.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Write(TInt64 aPos, TInt aLength,

                                 const TAny* aSrc, TInt aThreadHandle, TInt aOffset)

	{

	//

	// Set file position to where we want to write...

	//

	__MSFNSLOG

    __HOSTPRINT4(_L("\n>>> HOST Write Pos=0x%lx LBA=0%lx 0x%x 0x%x"),

                 aPos, aPos/KBlockSize, aLength, aOffset);

	TBool localMessage = (aThreadHandle == KLocalMessageHandle);

	if(!localMessage)

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		localMessage = (msg.Handle() == KLocalMessageHandle);

		}

	TInt index = 0;

	if(!localMessage)

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		GetIndex(msg, aSrc, index);

		if (index < 0)

			return KErrArgument;

		}

	/* Calculate the end position */

	TInt64 end =  aPos + static_cast<TInt64>(aLength);

	/* check whether there is enough source data to read */

	TInt64 truncate;

	if (localMessage)

		{

		truncate = aLength - (((TPtr8* )aSrc)->Length() - aOffset);

	    __PXYPRINT1(_L("Descriptor length: %08x"), ((TPtr8* )aSrc)->Length());

		}

	else

		{

		RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

		truncate = aLength - (msg.GetDesLength(index) - aOffset);

	    __PXYPRINT1(_L("Descriptor length: %08x"), msg.GetDesLength(index));

		}

	__PXYPRINT1(_L("Offset: %08x"), aOffset);

	__PXYPRINT1(_L("Truncate: 0x%lx"), truncate);

	/* if truncate is > 0  we are short of source data as claimed by the aLength. Hence adjust the 'end' */

	if (truncate > 0)

		{

		end -= truncate;

		}

	iBuf.SetMax();

    TInt r;

    TInt64 mediaPos;

	while (aPos < end)

        {

		TInt len = end - aPos;

        mediaPos = aPos;

        r = iMsDataMemMap.CheckBlockInRange(mediaPos, len);

        if (r != KErrNone)

            {

            __HOSTPRINT1(_L("<<< HOST Write ret=%d"), r);

            return r;

            }

		if (localMessage)

			{

			r = iUsbHostMsLun.Write(mediaPos, len, ((TPtr8*)aSrc)->MidTPtr(aOffset));

			if (r != KErrNone)

                {

                __HOSTPRINT1(_L("<<< HOST Write ret=%d"), r);

                return r;

                }

			}

		else

			{

			if (len > iBuf.Length())

				len = iBuf.Length();

			RMessage2 msg(*(RMessagePtr2 *) &aThreadHandle);

			r = msg.Read(index, iBuf, aOffset);

			if (r != KErrNone)

                {

                __HOSTPRINT1(_L("<<< HOST Write ret=%d"), r);

                return r;

                }

			r = iUsbHostMsLun.Write(mediaPos, len, iBuf);

			if (r != KErrNone)

                {

                __HOSTPRINT1(_L("<<< HOST Write ret=%d"), r);

                return r;

                }

			}

        aPos += len;

        aOffset += len;

        }

    __HOSTPRINT1(_L("<<< HOST Write ret=%d"), KErrNone);

	return KErrNone;

	}

/**

Write to the proxy drive and pass flags to driver

@param aPos    The address from where the write begins.

@param aLength The length of the write.

@param aSrc    A descriptor of the memory buffer from which to write.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aSrc to write the data to.

@param aFlags  Flags to be passed into the driver.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Write(TInt64 aPos, TInt aLength,

                                 const TAny* aSrc, TInt aThreadHandle, TInt aOffset, TInt /* aFlags */)

	{

	__MSFNSLOG

	return Write(aPos, aLength, aSrc, aThreadHandle, aOffset);

	}

/**

Write to the proxy drive.

@param aPos    The address from where the write begins.

@param aSrc    A descriptor of the memory buffer from which to write.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Write(TInt64 aPos,const TDesC8& aSrc)

	{

	__MSFNSLOG

    __HOSTPRINT3(_L("\n>>> HOST Write Pos=0x%lx LBA=0x%lx 0x%x"),

                 aPos, aPos/KBlockSize, aSrc.Length());

	return iUsbHostMsLun.Write(iMsDataMemMap.GetDataPos(aPos), aSrc.Length(), aSrc);

	}

/**

Get the proxy drive's capabilities information.

@param anInfo A descriptor of the connected drives capabilities.

@return system wide error code

*/

TInt CUsbHostMsProxyDrive::Caps(TDes8& anInfo)

	{

	__MSFNSLOG

    __HOSTPRINT(_L("\n>>> HOST Caps"));

	TLocalDriveCapsV6Buf caps;

    caps.FillZ();

    TLocalDriveCapsV6& c = caps();

	c.iType = EMediaHardDisk;

    c.iConnectionBusType = EConnectionBusUsb;

	c.iDriveAtt = KDriveAttLocal | KDriveAttRemovable | KDriveAttExternal;

	c.iMediaAtt = KMediaAttFormattable;

	c.iFileSystemId = KDriveFileSysFAT;

	TCapsInfo capsInfo;

	TInt r = iUsbHostMsLun.Caps(capsInfo);

	if (KErrNone == r)

		{

        c.iBlockSize = capsInfo.iBlockLength;

        TUint64 size = iMsDataMemMap.DataSize();

        if (size == 0)

            {

            // No valid partitions so specify the size of the disk

            size = static_cast<TUint64>(capsInfo.iNumberOfBlocks) * capsInfo.iBlockLength;

            }

        c.iSize = size;

        c.iEraseBlockSize = 0;

        if (capsInfo.iWriteProtect)

            {

            c.iMediaAtt |= KMediaAttWriteProtected;

            }

        __HOSTPRINT4(_L("<<< HOST Caps Block[num=0x%x size=0x%x] Media[size=0x%lx WP=0x%x]"),

                    capsInfo.iNumberOfBlocks, capsInfo.iBlockLength,

		            caps().iSize, caps().iMediaAtt);

		}

	else

        {

        __HOSTPRINT(_L("<<< HOST Caps Media Not Present"));

		c.iType = EMediaNotPresent;

		if(r != KErrNotReady)

			r = KErrUnknown;

        }

	anInfo = caps.Left(Min(caps.Length(),anInfo.MaxLength()));

	return r;

	}

/**

Format the proxy drive. The drive is assumed to be a single partition. The

partition size is equivalent to the size of the media.

@param aPos    The position of the data which is being formatted.

@param aLength [IN] The length of the data which is being formatted. [OUT] The

length of data formatted, truncated when end of drive is reached.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Erase(TInt64 aPos, TInt& aLength)

	{

	__MSFNSLOG

    __HOSTPRINT3(_L("\n HOST Erase Pos=0x%lx LBA=0x%lx 0x%x"),

                 aPos, aPos/KBlockSize, aLength);

    TInt err = iMsDataMemMap.TranslateDataPos(aPos, aLength);

    if (err)

        return err;

    err = iUsbHostMsLun.Erase(aPos, aLength);

    return err;

	}

/**

Format the proxy drive.

@param aPos    The position of the data which is being formatted.

@param aLength The length of the data which is being formatted.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Format(TInt64 aPos, TInt aLength)

	{

	__MSFNSLOG

    return Erase(aPos, aLength);

	}

/**

Format the connected drive.

@param anInfo Device specific format information.

@return system wide error code.

*/

TInt CUsbHostMsProxyDrive::Format(TFormatInfo& aInfo)

	{

	__MSFNSLOG

    const TInt KDefaultMaxBytesPerFormat = 0x100 * TMsDataMemMap::KSectorSize;  // 128K

    if (aInfo.i512ByteSectorsFormatted < 0)

        return KErrArgument;

    if (!aInfo.iFormatIsCurrent)

        {

        aInfo.iFormatIsCurrent = ETrue;

        aInfo.i512ByteSectorsFormatted = 0;

        aInfo.iMaxBytesPerFormat = KDefaultMaxBytesPerFormat;

		TLocalDriveCapsV6Buf caps;

		TInt r = Caps(caps);

		if (r != KErrNone)

			return r;

        iMsDataMemMap.InitDataArea(caps().iSize);

        }

    TInt64 pos = static_cast<TInt64>(aInfo.i512ByteSectorsFormatted) << TMsDataMemMap::KFormatSectorShift;

    TInt length = aInfo.iMaxBytesPerFormat;

    TInt r = Erase(pos, length);

    if (r == KErrNone)

        {

        length += TMsDataMemMap::KSectorSize - 1;

        length >>= TMsDataMemMap::KFormatSectorShift;

        aInfo.i512ByteSectorsFormatted += length;

        }

    return r;

    }

TInt CUsbHostMsProxyDrive::NotifyChange(TDes8 &aChanged,TRequestStatus* aStatus)

	{

	__MSFNSLOG

	iUsbHostMsLun.NotifyChange(aChanged, *aStatus);

	if(*aStatus != KRequestPending)

		return KErrUnknown;

	return KErrNone;

	}

void CUsbHostMsProxyDrive::NotifyChangeCancel()

	{

	__MSFNSLOG

	iUsbHostMsLun.NotifyChangeCancel();

	}

TInt CUsbHostMsProxyDrive::SetMountInfo(const TDesC8* /*aMountInfo*/,TInt /*aMountInfoThreadHandle=KCurrentThreadHandle*/)

    {

	__MSFNSLOG

    return KErrNone;

    }

TInt CUsbHostMsProxyDrive::ForceRemount(TUint aFlags)

    {

	__MSFNSLOG

    iUsbHostMsLun.ForceRemount(aFlags);

    return KErrNone;

    }

TInt CUsbHostMsProxyDrive::Unlock(TMediaPassword& /*aPassword*/, TBool /*aStorePassword*/)

    {

	__MSFNSLOG

    return KErrNotSupported;

    }

TInt CUsbHostMsProxyDrive::Lock(TMediaPassword& /*aOldPassword*/, TMediaPassword& /*aNewPassword*/, TBool /*aStorePassword*/)

    {

	__MSFNSLOG

    return KErrNotSupported;

    }

TInt CUsbHostMsProxyDrive::Clear(TMediaPassword& /*aPassword*/)

    {

	__MSFNSLOG

    return KErrNotSupported;

    }

TInt CUsbHostMsProxyDrive::ErasePassword()

    {

	__MSFNSLOG

    return KErrNotSupported;

    }

TInt CUsbHostMsProxyDrive::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput)

	{

	switch(aInterfaceId)

		{

		case ELocalBufferSupport:

			return KErrNone;

		case EFinalised:

			{

			TBool isFinalised = (TBool)aInput;

			if(isFinalised)

				{

				iUsbHostMsLun.SuspendLun();

				}

			}

			return KErrNone;

		default:

			return KErrNotSupported;

		}

	}