// Copyright (c) 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".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Partition Management for Embedded MMC devices

//

//

#include <emmcptn.h>

#include "mmc.h"

#include "bgahsmmcptn.h"

#include "medmmc.h"

#include "toc.h"

//#define __DEBUG_PARTITIONS_

//#define __DEBUG_CHECK_PARTITION_

class DBB5PartitionInfo : public DEMMCPartitionInfo

	{

public:

	 DBB5PartitionInfo();

	~DBB5PartitionInfo();

public:

	virtual TInt Initialise(DMediaDriver* aDriver);

	virtual TInt PartitionInfo(TPartitionInfo& anInfo, const TMMCCallBack& aCallBack);

	virtual TInt PartitionCaps(TLocDrv& aDrive, TDes8& aInfo);

	TInt HalFunction(TInt aFunction, TAny* a1, TAny* a2);

protected:

	void SetPartitionEntry(TPartitionEntry* aEntry, TUint aFirstSector, TUint aNumSectors);

private:

	virtual TInt ReadPartition(TUint32 aPtOffset);

	virtual TInt ReadPartition(TUint32 aPtOffset, TUint aNumBlocks);

	static void SessionEndCallBack(TAny* aSelf);

	void DoSessionEndCallBack();

	TInt DecodeTOCPartitionInfo();

	TInt DecodeBB5PartitionInfo();

	TInt CheckPartitionBoundaries(TInt aStart, TInt aEnd);

	TInt GetPartitionSizeInSectors(TUint aPartition, TUint32& aSize);

	TInt GetPartitionOffset(TUint32& aPtOffset);

	TInt SelectNextPartition();

	TInt ReadTOCVersionInfo(TUint32& aOffset);

	void DecodeVersionInfo();

private:	

	enum TMediaRequest

	    {

        EIdle                    = 0x00,

        EDecodeBB5PartitionInfo  = 0x01,

        EDecodeTOCPartitionInfo  = 0x02,        

        EReadImageVersionInfo    = 0x03,	    

	    };

protected:

	DMediaDriver*	iDriver;

	TPartitionInfo* iPartitionInfo;

	TMMCCallBack	iSessionEndCallBack;

	TMMCCallBack	iCallBack;		   // Where to report the PartitionInfo completion

	DMMCSession*	iSession;

	TMMCard*		iCard;

	TUint8* 		iIntBuf;

	TUint32 		iPartitionAttributes[KMaxLocalDrives];

	TBool           iCheckTOC;

	Toc*            iTocPtr;

	TUint32			iSelectedPartition;	

	TMediaRequest   iMedReq;

// Version Info Stuff	

	TBool            iVersionInfoRead;    

    TUint32          iVersionInfoItems; /** Amount of version info items */

    TVersionInfoItem iVersionInfo[KMaxSectionItems]; /** Array for keep whole Version Info structures */

    TUint32          iTocCount;

	};

/*****************************************************************************/

/*                                                                           */

/* NAME                                                                      */

/*      halFunction                                                          */

/* DESCRIPTION                                                               */

/*      This function gets HAL queries via EHalGroupMedia device 1           */

/*      This function is registered in the end of DoCreate                   */

/* PARAMETERS                                                                */

/*      TAny* aPtr      pointer to DMediaDriverNand object                   */

/*      TInt  aFunction requested function:                                  */

/*            1 - NAND block size                                            */

/*            2 - Is separate erase command supported  ETrue/EFalse          */

/*      TAny* a1        address to user side variable, block size is saved   */

/*                      to this address                                      */

/*      TAny* a2        not used                                             */

/* RETURN VALUES                                                             */

/*      KErrNone                                                             */

/* NOTES                                                                     */

/*                                                                           */

/*****************************************************************************/

LOCAL_C TInt halFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2)

    {

    DBB5PartitionInfo* pI = (DBB5PartitionInfo*)aPtr;

    return pI->HalFunction(aFunction,a1,a2);

    }

DBB5PartitionInfo::DBB5PartitionInfo()

  : iSessionEndCallBack(DBB5PartitionInfo::SessionEndCallBack, this),

    iCheckTOC(EFalse),iMedReq(EIdle),iVersionInfoItems(0)

	{

	}

DBB5PartitionInfo::~DBB5PartitionInfo()

	{

	delete iSession;

	if (iVersionInfoRead)

	    {

	    TInt r = Kern::RemoveHalEntry(EHalGroupNandMedia,ENandMediaDevice1);

	    __KTRACE_OPT(KPBUSDRV, Kern::Printf("~DBB5PartitionInfo: Removed HAL Entry %d",r));

	    r = r; //get rid of warning, nothing we can do with the warning

	    }

	if (iTocPtr)

	    {

	    delete iTocPtr;

	    }

	}

TInt DBB5PartitionInfo::Initialise(DMediaDriver* aDriver)

	{

	iDriver = aDriver;

	DMMCSocket* socket = ((DMMCSocket*)((DPBusPrimaryMedia*)(iDriver->iPrimaryMedia))->iSocket);

	if(socket == NULL)

		return(KErrNoMemory);

	DMMCStack* stack = socket->Stack(0);

	iCard = stack->CardP(((DPBusPrimaryMedia*)(iDriver->iPrimaryMedia))->iSlotNumber);

	iSession = stack->AllocSession(iSessionEndCallBack);

	if (iSession == NULL)

		return(KErrNoMemory);

	iSession->SetStack(stack);

	iSession->SetCard(iCard);

	// this gets used before any access

	TInt bufLen, minorBufLen;

	stack->BufferInfo(iIntBuf, bufLen, minorBufLen);

	iSelectedPartition = TExtendedCSD::ESelectUserArea;

	iTocPtr = new Toc();

	return(KErrNone);

	}

TInt DBB5PartitionInfo::PartitionInfo(TPartitionInfo& aInfo, const TMMCCallBack& aCallBack)

	{

    __KTRACE_OPT(KPBUSDRV,Kern::Printf(">DBB5PartitionInfo:PartitionInfo"));

	iPartitionInfo = &aInfo;

	iPartitionInfo->iPartitionCount = 0;

	iCallBack = aCallBack;

	iVersionInfoRead = EFalse;

	// Always check the user partition first

	iSelectedPartition = TExtendedCSD::ESelectUserArea;

	iSession->SetPartition(iSelectedPartition);

	// Preferred partition scheme is BB5, which is located in the last block of the media.

    TUint32 ptiOffset = 0;

    TInt r = KErrNone;

    do

    	{

	    r = GetPartitionOffset(ptiOffset);

	    if(r == KErrNone)

	    	{

		    r = ReadPartition(ptiOffset);

		    iMedReq = (KErrNone==r) ? EDecodeBB5PartitionInfo : EIdle;

		    break;

	    	}

	    r = SelectNextPartition();

    	}

    while(r != KErrNotFound);    

    __KTRACE_OPT(KPBUSDRV,Kern::Printf("<DBB5PartitionInfo::PartitionInfo(%d)",r));

	return r;

	}

// retrieves size in terms of sectors

TInt DBB5PartitionInfo::GetPartitionSizeInSectors(TUint aPartition, TUint32& aSize)

	{

    __KTRACE_OPT(KPBUSDRV,Kern::Printf(">DBB5PartitionInfo: GetPartitionSizeInSectors(%d)",aPartition));

	TInt r = KErrNone;

	TUint32 size = 0;

	const TExtendedCSD& extCsd = iCard->ExtendedCSD();

	switch(aPartition)

		{

		case TExtendedCSD::ESelectUserArea:

			{

			size = (TUint32)(iCard->DeviceSize64() / KSectorSize);

			if(extCsd.ExtendedCSDRev() >= TExtendedCSD::EExtendedCSDRev1_5)

				{

				TUint32 otherPartitionsSize = 

					extCsd.GeneralPurposePartition1SizeInSectors()

					+ extCsd.GeneralPurposePartition2SizeInSectors()

					+ extCsd.GeneralPurposePartition3SizeInSectors()

					+ extCsd.GeneralPurposePartition4SizeInSectors();

					__ASSERT_DEBUG(size >= otherPartitionsSize, Kern::Fault("DBB5PartitionInfo size mismatch", __LINE__));

					size -= otherPartitionsSize;

				}

			}

			break;

		case TExtendedCSD::ESelectBootPartition1:

		case TExtendedCSD::ESelectBootPartition2:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_3) ? 

				0 : extCsd.BootSizeInSectors();

			break;

		case TExtendedCSD::ESelectRPMB:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_5) ? 

				0 : extCsd.RpmbSizeInSectors();

			break;

		case TExtendedCSD::ESelectGPAPartition1:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_5) ? 

				0 : extCsd.GeneralPurposePartition1SizeInSectors();

			break;

		case TExtendedCSD::ESelectGPAPartition2:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_5) ? 

				0 : extCsd.GeneralPurposePartition2SizeInSectors();

			break;

		case TExtendedCSD::ESelectGPAPartition3:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_5) ? 

				0 : extCsd.GeneralPurposePartition3SizeInSectors();

			break;

		case TExtendedCSD::ESelectGPAPartition4:

			size = (extCsd.ExtendedCSDRev() < TExtendedCSD::EExtendedCSDRev1_5) ? 

				0 : extCsd.GeneralPurposePartition4SizeInSectors();

			break;

		default:

			// unknown partition

			size = 0;

			r = KErrNotSupported;

			break;

		}

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<DBB5PartitionInfo: GetPartitionSizeInSectors(size %d, r %d)",size,r));

	aSize = size;	

	return r;

	}

TInt DBB5PartitionInfo::GetPartitionOffset(TUint32& aPtiOffset)

	{

	TInt r = GetPartitionSizeInSectors(iSelectedPartition, aPtiOffset);

	if((r != KErrNone) || (aPtiOffset == 0))

		{

		// error reading or partition not supported, skip

		r = KErrNotSupported;

		}

	else

		{			

		// need to determine correct end of the partition

		aPtiOffset -= KPIOffsetFromMediaEnd;

		}

	return r;

	}

TInt DBB5PartitionInfo::SelectNextPartition()

	{

    __KTRACE_OPT(KPBUSDRV,Kern::Printf(">DBB5PartitionInfo: SelectNextPartition (%d)",iSelectedPartition));

	TExtendedCSD extCsd = iCard->ExtendedCSD();

	TUint maxPartition = TExtendedCSD::ESelectUserArea;

	if(extCsd.ExtendedCSDRev() >= TExtendedCSD::EExtendedCSDRev1_5)

		{

		// v4.4 supports UDA, 2x BOOT, RPMB and 4x GPAP partitions

		maxPartition = TExtendedCSD::ESelectGPAPartition4;

		}

#ifdef EMMC_BOOT_PARTITION_ACCESS_ENABLED

	else if(extCsd.ExtendedCSDRev() >= TExtendedCSD::EExtendedCSDRev1_3)

		{

		// v4.3 supports up to two BOOT partitions

		maxPartition = TExtendedCSD::ESelectBootPartition2;

		}

#endif // EMMC_BOOT_PARTITION_ACCESS_ENABLED

	++iSelectedPartition;

	// skip through to GPAP1 if either the currently selected partition is RPMB or

	// if it is one of the BOOT partitions and boot partition access is not enabled

	if((iSelectedPartition == TExtendedCSD::ESelectRPMB)

#ifndef EMMC_BOOT_PARTITION_ACCESS_ENABLED 

		|| (iSelectedPartition == TExtendedCSD::ESelectBootPartition1)

		|| (iSelectedPartition == TExtendedCSD::ESelectBootPartition2)

#endif	   

		)

		{

		iSelectedPartition = TExtendedCSD::ESelectGPAPartition1;

		}

	TInt r = KErrNone;

	if(iSelectedPartition > maxPartition)

		{

		r = KErrNotFound; // no more partitions to be checked

		}

	else

		{

		iSession->SetPartition(iSelectedPartition);

		}

	__KTRACE_OPT(KPBUSDRV,Kern::Printf("<DBB5PartitionInfo: SelectNextPartition (%d) err (%d)",iSelectedPartition, r));

	return r;	

	}	

TInt DBB5PartitionInfo::ReadPartition(TUint32 aPtOffset)

    {

    return ReadPartition(aPtOffset,1);

    }

// returns KErrCompletion on success after having checked all partitions

TInt DBB5PartitionInfo::ReadPartition(TUint32 aPtOffset, TUint aNumBlocks)

    {

    __ASSERT_ALWAYS(aNumBlocks > 0,Kern::Fault("DBB5PartitionInfo:RP aNumBlocks = 0", __LINE__));

	// If media driver is persistent (see EMediaDriverPersistent)

	// the card may have changed since last power down, so reset CID

	iSession->SetCard(iCard);

	if (aNumBlocks == 1)

	    {

	    iSession->SetupCIMReadBlock(aPtOffset, iIntBuf);

	    }

	else

	    {

	    iSession->SetupCIMReadBlock(aPtOffset, iIntBuf,aNumBlocks);	    

	    }

	TInt r = iDriver->InCritical();

	if (r == KErrNone)

		r = iSession->Engage();

	if(r != KErrNone)

		iDriver->EndInCritical();

	return(r);

	}

TInt DBB5PartitionInfo::PartitionCaps(TLocDrv& aDrive, TDes8& aInfo)

	{

	TLocalDriveCapsV6Buf& Info = static_cast< TLocalDriveCapsV6Buf&> (aInfo);

	if (aDrive.iPartitionType == KPartitionTypePagedData)

		{

		Info().iFileSystemId = KDriveFileNone;

		Info().iDriveAtt |= KDriveAttHidden;

		}

	else if (aDrive.iPartitionType == KPartitionTypeRofs)

		{

		Info().iFileSystemId = KDriveFileSysROFS;

		Info().iMediaAtt &= ~KMediaAttFormattable;

		Info().iMediaAtt |= KMediaAttWriteProtected;

		}

	else if ((aDrive.iPartitionType == KPartitionTypeROM) ||

			 (aDrive.iPartitionType == KPartitionTypeEmpty))

		{

		Info().iFileSystemId = KDriveFileNone;

		Info().iMediaAtt &= ~KMediaAttFormattable;

		Info().iMediaAtt |= KMediaAttWriteProtected;

		}

    else if ((aDrive.iPartitionType == KPartitionTypePartitionMagic) || //CPS/PMM

             (aDrive.iPartitionType == KPartitionTypeSymbianCrashLog))

        {

        Info().iFileSystemId = KDriveFileNone;

        Info().iMediaAtt |= KMediaAttFormattable;

        }

	else if ( PartitionIsFAT(aDrive.iPartitionType) || PartitionIsFAT32(aDrive.iPartitionType)	)

		{		

		Info().iDriveAtt |= iPartitionAttributes[aDrive.iPartitionNumber];

		}

	return KErrNone;

	}

void DBB5PartitionInfo::SessionEndCallBack(TAny* aSelf)

	{

	DBB5PartitionInfo& self = *static_cast<DBB5PartitionInfo*>(aSelf);

	self.DoSessionEndCallBack();

	}

void DBB5PartitionInfo::DoSessionEndCallBack()

	{

	iDriver->EndInCritical();

	__KTRACE_OPT(KPBUSDRV,Kern::Printf(">DBB5PartitionInfo:DoSessionEndCallBack (%d)",iMedReq));

	TInt r = iSession->EpocErrorCode();

	if (KErrNone == r)

	    {

	    switch (iMedReq)

	        {

	        case EDecodeBB5PartitionInfo   : 

	            {

                r = DecodeBB5PartitionInfo();

                if (r == KErrNotFound)

                    {

                    // Check for TOC in this partition instead

                    TUint32 size = 0;

                    r = GetPartitionSizeInSectors(iSelectedPartition,size);

                    if ((KErrNone == r) && (size >= KTocStartSector+1))

                        {

                        //Check partition size to see if TOC could be read (i.e. might be too small)

                        r = ReadPartition(KTocStartSector);

                        iMedReq = (KErrNone==r) ? EDecodeTOCPartitionInfo : EIdle;

                        return;

                        }                    

                    }

                // else - found BB5 check if next phys partition has anything to read...

                break;

	            }

	        case EDecodeTOCPartitionInfo   :

	            {

	            r = DecodeTOCPartitionInfo();

	            if (r == KErrNone)

	                {

	                //Found a TOC, read version info if available

	                TUint32 versOffset = 0;

	                iTocCount = 0; //Reset Toc entry counter

	                r = ReadTOCVersionInfo(versOffset);	                

	                if (r == KErrNotFound)

	                    {

	                    // No valid partitions present

	                    iMedReq = EIdle;

                        r = KErrNone;

	                    }

	                else

	                    {

	                    // Found something to read...

	                    r = ReadPartition(versOffset, 2);

	                    iMedReq = (KErrNone==r) ? EReadImageVersionInfo : EIdle;

	                    return;

	                    }

	                }

	            else

	                {

	                // TOC not found move on to next phys partition

	                iMedReq = EIdle;

	                r = KErrNone;

	                }

	            break;

	            }

	        case EReadImageVersionInfo     :

	            {	            

                DecodeVersionInfo();

                TUint32 versOffset = 0;

                iTocCount++;

                r = ReadTOCVersionInfo(versOffset);

                if (r == KErrNotFound)

                    {

                    //Finished parsing the current TOC                                 

                    //Mark version info as being read in order to report when finished later

                    iVersionInfoRead = ETrue;

                    iMedReq = EIdle;

                    r=KErrNone;

                    }

                else if (r==KErrNone)

                    {

                    // more partitions to read

                    r = ReadPartition(versOffset, 2);

                    iMedReq = (KErrNone==r) ? EReadImageVersionInfo : EIdle;

                    return;

                    }

                break;

	            }

	        default : Kern::Fault("DBB5PartitionInfo unknown request type", __LINE__);

	        }

	    }

	// Next physical partition will be search for if

	// BB5 entry was found, no TOC entry was found or no Version Information was found

	if(r == KErrNone)

		{

		// check next partition(s) for BB5

		TUint32 ptiOffset = 0;