// Copyright (c) 1999-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:

 // \e32\drivers\pbus\mmc\stack.cpp

 // 

 //

 #include <drivers/mmc.h>

 #include <kernel/kern_priv.h>

 #include <drivers/locmedia.h>

 #include "stackbody.h"

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "locmedia_ost.h"

 #ifdef __VC32__

 #pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

 #endif

 #include "stackTraces.h"

 #endif

 #ifdef __SMP__

 TSpinLock MMCLock(TSpinLock::EOrderGenericIrqHigh0);

 #endif

 #define ASSERT_NOT_ISR_CONTEXT	__ASSERT_DEBUG(NKern::CurrentContext()!=NKern::EInterrupt,DMMCSocket::Panic(DMMCSocket::EMMCUnblockingInWrongContext));

 #if !defined(__WINS__)

 #define DISABLEPREEMPTION TUint irq = __SPIN_LOCK_IRQSAVE(MMCLock);

 #define RESTOREPREEMPTION __SPIN_UNLOCK_IRQRESTORE(MMCLock,irq);

 #else

 #define DISABLEPREEMPTION

 #define RESTOREPREEMPTION										   

 #endif

 //#define ENABLE_DETAILED_SD_COMMAND_TRACE

 // default length of minor buffer - must have at least enough space for one sector

 const TInt KMinMinorBufSize = 512;

 //	MultiMedia Card Controller - Generic level code for controller, intermediate

 //	level code for media change and power supply handling

 EXPORT_C TUint TCSD::CSDField(const TUint& aTopBit, const TUint& aBottomBit) const

 /**

  * Extract bitfield from CSD

  */

 	{

 	const TUint indexT=KMMCCSDLength-1-aTopBit/8;

 	const TUint indexB=KMMCCSDLength-1-aBottomBit/8;

 	return(((indexT==indexB ? iData[indexT]

 			: (indexT+1)==indexB ? ((iData[indexT]<<8) | iData[indexT+1])

 			: ((iData[indexT]<<16) | (iData[indexT+1]<<8) | iData[indexT+2])

 			) >> (aBottomBit&7)) & ((1<<(aTopBit-aBottomBit+1))-1));

 	}

 //	--------  class TCSD  --------

 // Raw field accessor functions are defined in mmc.inl.  These functions return

 // values that require extra computation, such as memory capacity.

 EXPORT_C TUint TCSD::DeviceSize() const

 /**

  *

  * Calculate device capacity from CSD

  * 

  * Section 5.3, MMCA Spec 2.2 (Jan 2000)

  *

  * memory capacity = BLOCKNR * BLOCK_LEN

  * where

  *	BLOCKNR = (C_SIZE + 1) * MULT; MULT = 2 ** (C_MULT_SIZE + 2);

  *	BLOCK_LEN = 2 ** (READ_BL_LEN)

  *

  * memory capacity	= (C_SIZE + 1) * (2 ** (C_MULT_SIZE + 2)) * (2 ** READ_BL_LEN)

  *					= (C_SIZE + 1) * (2 ** (C_MULT_SIZE + 2 + READ_BL_LEN))

  *

  * @return Device Capacity

  */

 	{

 	__KTRACE_OPT(KPBUS1, Kern::Printf("csd:ds:0x%x,0x%x,0x%x", ReadBlLen(), CSize(), CSizeMult()));

 	const TUint blockLog = ReadBlLen();

 	if( blockLog > 11 )

 		return( 0 );

 	const TUint size = (CSize() + 1) << (2 + CSizeMult() + blockLog);

 	if( size == 0 )

 		return( 0xFFF00000 );

 	return( size );

 	}

 EXPORT_C TMMCMediaTypeEnum TCSD::MediaType() const

 /**

  * This function makes a rough approximation if media type based on supported

  * command classes (CCC).

  *

  * @return TMMCMediaTypeEnum describing the type of media.

  */

 	{

 	struct mediaTableEntry

 		{

 		TUint iMask;

 		TUint iValue;

 		TMMCMediaTypeEnum iMedia;

 		};

 	const TUint testMask = (KMMCCmdClassBlockRead|KMMCCmdClassBlockWrite|KMMCCmdClassErase|KMMCCmdClassIOMode);

 	static const mediaTableEntry mediaTable[] = 

 		{

 		{KMMCCmdClassBasic, 0,																  EMultiMediaNotSupported},

 		{testMask,			(KMMCCmdClassBlockRead|KMMCCmdClassBlockWrite|KMMCCmdClassErase), EMultiMediaFlash},

 		{testMask,			KMMCCmdClassBlockRead|KMMCCmdClassBlockWrite,					  EMultiMediaFlash},

 		{testMask,			KMMCCmdClassBlockRead|KMMCCmdClassErase,						  EMultiMediaROM},

 		{testMask,			KMMCCmdClassBlockRead,											  EMultiMediaROM},

 		{KMMCCmdClassIOMode,KMMCCmdClassIOMode,												  EMultiMediaIO},

 		{0,					0,																  EMultiMediaOther}

 		};

 	const TUint ccc = CCC();

 	const mediaTableEntry* ptr = mediaTable;

 	while( (ccc & ptr->iMask) != (ptr->iValue) )

 		ptr++;

     if (ptr->iMedia == EMultiMediaFlash)

         {

         // Further check PERM_WRITE_PROTECT and TMP_WRITE_PROTECT bits

         if (PermWriteProtect() || TmpWriteProtect())

             return EMultiMediaROM;

         }

 	return( ptr->iMedia );

 	}

 EXPORT_C TUint TCSD::ReadBlockLength() const

 /**

  * Calculates the read block length from the CSD.

  * READ_BL_LEN is encoded as a logarithm.

  *

  * @return The read block length 

  */

 	{

 	const TUint blockLog = ReadBlLen();

 	//SD version 2.0 or less the range is 0-11

 	//MMC version 4.1 or less the range is 0-11

 	//MMC version 4.2 the range is 0-14 (15 is reserved for future use)

 	//But we cannot differentiate among 4.x

 	//Hence , 0-14 is supported for 4.x

 	if (SpecVers() < 4)

 		{

 		if( blockLog > 11 )

 			return( 0 );

 		}

 	else

 		{

 		if(blockLog > 14)

 			return ( 0 );

 		}

 	return( 1 << blockLog );

 	}

 EXPORT_C TUint TCSD::WriteBlockLength() const

 /**

  * Calculates the write block length from the CSD.

  * WRITE_BL_LEN is encoded as a logarithm.

  *

  * @return The write block length 

  */

 	{

 	const TUint blockLog = WriteBlLen();

 	if( blockLog > 11 )

 		return( 0 );

 	return( 1 << blockLog );

 	}

 EXPORT_C TUint TCSD::EraseSectorSize() const

 /**

  * Calculates the erase sector size from the CSD.

  * SECTOR_SIZE is a 5 bit value, which is one less than the number of write

  *

  * @return The erase sector size

  */

 	{

 	if (SpecVers() < 3)

 		{

 		// V2.2 and earlier supports erase sectors. Read sector size from CSD(46:42) - confusingly now reassigned as

 		// erase group size. 

 		return( (EraseGrpSize()+1) * WriteBlockLength() );

 		}

 	else

 		{

 		// Support for erase sectors removed from V3.1 onwards

 		return(0);	

 		}

 	}

 EXPORT_C TUint TCSD::EraseGroupSize() const

 /**

  * Calculates the erase group size from the CSD.

  * ERASE_GRP_SIZE is a 5 bit value, which is one less than the number of erase

  * sectors in an erase group.

  *

  * @return The erase group size

  */

 	{

 	if (SpecVers() < 3)

 		{

 		// For V2.2 and earlier, the erase group size is held in CSD(41:37)  - confusingly now reassigned as the erase

 		// group multiplier. The units for this are erase sectors, so need to convert to write blocks and then bytes.

 		TUint erSecSizeInBytes=(EraseGrpSize()+1) * WriteBlockLength();

 		return( (EraseGrpMult()+1) * erSecSizeInBytes );

 		}

 	else

 		{

 		// For V3.1 onwards, the erase group size is determined by multiplying the erase group size - CSD(41:37) by the

 		// erase group multiplier - CSD(46:42)). The units for this are write blocks, so need to convert to bytes.  

 		TUint erGrpSizeInWrBlk = (EraseGrpSize()+1) * (EraseGrpMult()+1);

 		return(erGrpSizeInWrBlk * WriteBlockLength());

 		}	

 	}

 EXPORT_C TUint TCSD::MinReadCurrentInMilliamps() const

 /**

  * Calculates the minimum read current from the CSD.

  * VDD_R_CURR_MIN is a three bit value which is mapped to a number of mA.

  * 0 actually maps to 0.5mA, but has been rounded up.

  *

  * @return The minimum read current, in Milliamps

  */

 	{

 	static const TUint8 minConsumptionTable[] = {1,1,5,10,25,35,60,100};

 	return( minConsumptionTable[VDDRCurrMin()] );

 	}

 EXPORT_C TUint TCSD::MinWriteCurrentInMilliamps() const

 /**

  * Calculates the minimum write current from the CSD.

  * VDD_W_CURR_MIN is a three bit value which is mapped to a number of mA.

  *

  * @return The minimum write current, in Milliamps

  */

 	{

 	static const TUint8 minConsumptionTable[] = {1,1,5,10,25,35,60,100};

 	return( minConsumptionTable[VDDWCurrMin()] );

 	}

 EXPORT_C TUint TCSD::MaxReadCurrentInMilliamps() const

 /**

  * Calculates the maximum read current from the CSD.

  * VDD_R_CURR_MAX is a three bit value which is mapped to a number of mA.

  * 0 actually maps to 0.5mA, but has been rounded up.

  *

  * @return The maximum read current, in Milliamps

  */

 	{

 	static const TUint8 maxConsumptionTable[] = {1,5,10,25,35,45,80,200};

 	return( maxConsumptionTable[VDDRCurrMax()] );

 	}

 EXPORT_C TUint TCSD::MaxWriteCurrentInMilliamps() const

 /**

  * Calculates the maximum write current from the CSD.

  * VDD_W_CURR_MAX is a three bit value which is mapped to a number of mA.

  *

  * @return The maximum write current, in Milliamps

  */

 	{

 	static const TUint8 maxConsumptionTable[] = {1,5,10,25,35,45,80,200};

 	return( maxConsumptionTable[VDDWCurrMax()] );

 	}

 EXPORT_C TUint TCSD::MaxTranSpeedInKilohertz() const

 /**

  * TRAN_SPEED is an eight bit value which encodes three fields.

  * Section 5.3, MMCA Spec 2.2 (Jan 2000)

  *

  *	2:0	transfer rate unit	values 4 to 7 are reserved.

  *	6:3	time value

  *

  * @return Speed, in Kilohertz

  */

 	{

 	// tranRateUnits entries are all divided by ten so tranRateValues can be integers

 	static const TUint tranRateUnits[8] = {10,100,1000,10000,10,10,10,10};

 	static const TUint8 tranRateValues[16] = {10,10,12,13,15,20,25,30,35,40,45,50,55,60,70,80};

 	const TUint ts = TranSpeed();

 	return( tranRateUnits[ts&7] * tranRateValues[(ts>>3)&0xF] );

 	}

 //	--------  class TMMCard  --------

 TMMCard::TMMCard()

 : iIndex(0), iUsingSessionP(0), iFlags(0), iBusWidth(1)

 	{

 	// empty.

 	}

 EXPORT_C TBool TMMCard::IsReady() const

 /**

  * Predicate for if card is mounted and in standby/transfer/sleep state.

  *

  * @return ETrue if ready, EFalse otherwise.

  */

 	{

 	const TUint state = iStatus.State();

 	__KTRACE_OPT(KPBUS1, Kern::Printf("=mcc:ir:%d,0x%08x", IsPresent(), state));

 	OstTraceExt2( TRACE_INTERNALS, TMMCARD_ISREADY, "IsPresent=%d; state=0x%08x", IsPresent(), state );

 	return IsPresent() && (state == ECardStateStby || state == ECardStateTran || state == ECardStateSlp);

 	}

 EXPORT_C TBool TMMCard::IsLocked() const

 /**

  * Predicate for if card is locked

  * 

  * It would be useful to check if the CSD supports the password protection

  * feature.  Password protection was introduced in c3.1, 05/99 and SPEC_VERS

  * is encoded 0 |-> 1.0 - 1.2, 1 |-> 1.4, 3 |-> 2.2.  Some cards support

  * password locking but their CSD reports SPEC_VERS == 1.

  *

  * @return ETrue if locked, EFalse otherwise.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_ISLOCKED_ENTRY, this );

 	if ( !IsPresent() ) 

 		return( EFalse );

 	return( (TUint32(iStatus) & KMMCStatCardIsLocked) != 0 );

 	}

 TInt64 TMMCard::DeviceSize64() const

 /**

  * Returns the size of the MMC card in bytes

  * @return The size of the MMC card in bytes.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_DEVICESIZE64_ENTRY, this );

 	const TBool highCapacity = IsHighCapacity();

 	const TUint32 sectorCount = ExtendedCSD().SectorCount();

 	return ((highCapacity && sectorCount) ? (((TInt64)ExtendedCSD().SectorCount()) * 512) : (TInt64)CSD().DeviceSize());

 	}

 TUint32 TMMCard::PreferredWriteGroupLength() const

 /**

  * Returns the write group length.  Provided by the variant.

  * Default implementation returns a multiple of the write block length, as indicated by the CSD.

  * @return The preferred write group length.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_PREFERREDWRITEGROUPLENGTH_ENTRY, this );

 	return(CSD().WriteBlockLength() << 5);	// 16K for a standard 512byte block length

 	}

 TInt TMMCard::GetFormatInfo(TLDFormatInfo& /*aFormatInfo*/) const

 /**

  * Returns the preferred format parametersm for the partition.

  * Implemented at the Variant layer.

  * @return Standard Symbian OS error code.

  */

 	{

 	return KErrNotSupported;

 	}

 TUint32 TMMCard::MinEraseSectorSize() const

 /**

  * Returns the minimum erase sector size.  Provided by the variant.

  * Default implementation returns the erase sector size, as indicated by the CSD.

  * @return The minimum erase sector size.

  */

 	{

 	return CSD().EraseSectorSize();

 	}

 TUint32 TMMCard::EraseSectorSize() const

 /**

  * Returns the recommended erase sector size.  Provided by the variant.

  * Default implementation returns the erase sector size, as indicated by the CSD.

  * @return The recommended erase sector size.

  */

 	{

 	return CSD().EraseSectorSize();

 	}

 LOCAL_C TBool IsPowerOfTwo(TInt aNum)

 //

 // Returns ETrue if aNum is a power of two

 //

 	{

 	return (aNum != 0 && (aNum & -aNum) == aNum);

 	}

 TInt TMMCard::GetEraseInfo(TMMCEraseInfo& aEraseInfo) const

 /**

  * Return info. on erase services for this card

  * @param aEraseInfo A reference to the TMMCEraseInfo to be filled in with the erase information.

  * @return Symbian OS error code.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_GETERASEINFO_ENTRY, this );

 	// Check whether this card supports Erase Class Commands. Also, validate the erase group size

 	if ((CSD().CCC() & KMMCCmdClassErase) && IsPowerOfTwo(CSD().EraseGroupSize()))

 		{

 		// This card supports erase cmds. Also, all versions of MMC cards support Erase Group commands (i.e. CMD35, CMD36).

 		OstTrace0( TRACE_INTERNALS, TMMCARD_GETERASEINFO, "Card supports erase class commands" );

 		aEraseInfo.iEraseFlags=(KMMCEraseClassCmdsSupported|KMMCEraseGroupCmdsSupported); 

 		// Return the preferred size to be used as the unit for format operations. We need to return a sensible

 		// multiple of the erase group size - as calculated by the CSD. A value around 1/32th of the total disk

 		// size generally results in an appropriate number of individual format calls.

 		const TInt64 devSizeDividedBy32=(DeviceSize64()>>5);

 		aEraseInfo.iPreferredEraseUnitSize=CSD().EraseGroupSize();

 		while (aEraseInfo.iPreferredEraseUnitSize < devSizeDividedBy32)

 			aEraseInfo.iPreferredEraseUnitSize<<=1;

 		// Return the smallest size that can be used as the unit for erase operations. For erase group commands, this

 		// is the erase group size. 

 		aEraseInfo.iMinEraseSectorSize=CSD().EraseGroupSize();

 		} 

 	else	

 		aEraseInfo.iEraseFlags=0;

 	OstTraceFunctionExitExt( TMMCARD_GETERASEINFO_EXIT, this, KErrNone );

 	return KErrNone;

 	}

 TUint TMMCard::MaxTranSpeedInKilohertz() const

 /**

  * Returns the maximum supported clock rate for the card, in Kilohertz.

  * @return Speed, in Kilohertz

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_MAXTRANSPEEDINKILOHERTZ_ENTRY, this );

 	// Default implementation obtains the transaction speed from the CSD

 	TUint32 highSpeedClock = HighSpeedClock();

 	return(highSpeedClock ? highSpeedClock : iCSD.MaxTranSpeedInKilohertz());

 	}

 TInt TMMCard::MaxReadBlLen() const

 /**

  * Returns the maximum read block length supported by the card encoded as a logarithm

  * Normally this is the same as the READ_BL_LEN field in the CSD register,

  * but for high capacity cards (>- 2GB) this is set to a maximum of 512 bytes,

  * if possible, to try to avoid compatibility issues.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_MAXREADBLLEN_ENTRY, this );

 	const TInt KDefaultReadBlockLen = 9;	// 2^9 = 512 bytes

 	const TCSD& csd = CSD();

 	TInt blkLenLog2 = csd.ReadBlLen();

 	if (blkLenLog2 > KDefaultReadBlockLen)

 		{

 		__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mrbl %d", blkLenLog2));

 		OstTrace1( TRACE_INTERNALS, TMMCARD_MAXREADBLLEN1, "Block length 1=%d", blkLenLog2 );

 		if (csd.ReadBlPartial() || CSD().SpecVers() >= 4)

 			{

 			//

 			// MMC System Spec 4.2 states that 512 bytes blocks are always supported, 

 			// regardless of the state of READ_BL_PARTIAL 

 			//

 			blkLenLog2 = KDefaultReadBlockLen;	

 			__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mrbl -> %d", blkLenLog2));

 			OstTrace1( TRACE_INTERNALS, TMMCARD_MAXREADBLLEN2, "Block length 2=%d", blkLenLog2 );

 			}

 		}

 	OstTraceFunctionExitExt( TMMCARD_MAXREADBLLEN_EXIT, this, blkLenLog2 );

 	return blkLenLog2;

 	}

 TInt TMMCard::MaxWriteBlLen() const

 /**

  * Returns the maximum write block length supported by the card encoded as a logarithm

  * Normally this is the same as the WRITE_BL_LEN field in the CSD register,

  * but for high capacity cards (>- 2GB) this is set to a maximum of 512 bytes,

  * if possible, to try to avoid compatibility issues.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARD_MAXWRITEBLLEN_ENTRY, this );

 	const TInt KDefaultWriteBlockLen = 9;	// 2^9 = 512 bytes

 	const TCSD& csd = CSD();

 	TInt blkLenLog2 = csd.WriteBlLen();

 	if (blkLenLog2 > KDefaultWriteBlockLen)

 		{

 		__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mrbl %d", blkLenLog2));

 		OstTrace1( TRACE_INTERNALS, TMMCARD_MAXWRITEBLLEN1, "Block length 1=%d", blkLenLog2 );

 		if (csd.WriteBlPartial() || CSD().SpecVers() >= 4)

 			{

 			//

 			// MMC System Spec 4.2 states that 512 bytes blocks are always supported, 

 			// regardless of the state of READ_BL_PARTIAL 

 			//

 			blkLenLog2 = KDefaultWriteBlockLen;	

 			__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mrbl -> %d", blkLenLog2));

 			OstTrace1( TRACE_INTERNALS, TMMCARD_MAXWRITEBLLEN2, "Block length 1=%d", blkLenLog2 );

 			}

 		}

 	OstTraceFunctionExitExt( TMMCARD_MAXWRITEBLLEN_EXIT, this, blkLenLog2 );

 	return blkLenLog2;

 	}

 //	--------  class TMMCardArray  --------

 EXPORT_C TInt TMMCardArray::AllocCards()

 /** 

  * Allocate TMMCard objects for iCards and iNewCardsArray.

  * This function is called at bootup as part of stack allocation so there

  * is no cleanup if it fails.

  *

  * @return KErrNone if successful, Standard Symbian OS error code otherwise.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARDARRAY_ALLOCCARDS_ENTRY, this );

 	for (TUint i = 0; i < KMaxMMCardsPerStack; ++i)

 		{

 		// zeroing the card data used to be implicit because embedded in

 		// CBase-derived DMMCStack.

 		if ((iCards[i] = new TMMCard) == 0)

 		    {

 			OstTraceFunctionExitExt( TMMCARDARRAY_ALLOCCARDS_EXIT1, this, KErrNoMemory );

 			return KErrNoMemory;

 		    }

 		iCards[i]->iUsingSessionP = 0;

 		if ((iNewCards[i] = new TMMCard) == 0)

 		    {

 			OstTraceFunctionExitExt( TMMCARDARRAY_ALLOCCARDS_EXIT2, this, KErrNoMemory );

 			return KErrNoMemory;

 		    }

 		iNewCards[i]->iUsingSessionP = 0;

 		}

 	OstTraceFunctionExitExt( TMMCARDARRAY_ALLOCCARDS_EXIT3, this, KErrNone );

 	return KErrNone;

 	}

 void TMMCardArray::InitNewCardScan()

 /**

  * Prepare card array for new scan.

  */

 	{

 	OstTraceFunctionEntry1( TMMCARDARRAY_INITNEWCARDSCAN_ENTRY, this );

 	iNewCardsCount=0;

 	OstTraceFunctionExit1( TMMCARDARRAY_INITNEWCARDSCAN_EXIT, this );

 	}

 void TMMCardArray::MoveCardAndLockRCA(TMMCard& aSrcCard,TMMCard& aDestCard,TInt aDestIndex)

 /**

  * Copy card object and lock RCA.

  */

 	{

 	OstTraceExt2(TRACE_FLOW, TMMCARDARRAY_MOVECARDANDLOCKRCA_ENTRY, "TMMCardArray::MoveCardAndLockRCA;aDestIndex=%d;this=%x", aDestIndex, (TUint) this);

 	__KTRACE_OPT(KPBUS1, Kern::Printf("=mca:mclr:%d", aDestIndex));

 	aDestCard.iCID=aSrcCard.iCID;

 	aDestCard.iRCA=aSrcCard.iRCA;

 	aDestCard.iCSD=aSrcCard.iCSD;

 	aDestCard.iIndex=aDestIndex;		// Mark card as being present

 	aDestCard.iFlags=aSrcCard.iFlags;

 	aDestCard.iBusWidth=aSrcCard.iBusWidth;

 	aDestCard.iHighSpeedClock = aSrcCard.iHighSpeedClock;

 	iOwningStack->iRCAPool.LockRCA(aDestCard.iRCA);

 	// Now that we have transferred ownership, reset the source card

 	aSrcCard.iRCA = aSrcCard.iIndex = aSrcCard.iFlags = 0;

 	aSrcCard.iBusWidth = 1;

 	aSrcCard.iHighSpeedClock = 0;

 	aSrcCard.iUsingSessionP = NULL;

 	OstTraceFunctionExit1( TMMCARDARRAY_MOVECARDANDLOCKRCA_EXIT, this );

 	}

 EXPORT_C void TMMCardArray::AddNewCard(const TUint8* aCID,TRCA* aNewRCA)

 /**

  * Found a new card to add to the array. Add it to a separate array for now

  * since we need to know all the cards present before we start replacing old

  * entries.

  */

 	{

 	OstTraceFunctionEntryExt( TMMCARDARRAY_ADDNEWCARD_ENTRY, this );

 	// Store the CID in the next free slot

 	NewCard(iNewCardsCount).iCID = aCID;

 	*aNewRCA=0;

 	// Now let's look if we've seen this card before

 	for ( TUint i=0 ; i<iOwningStack->iMaxCardsInStack ; i++ )

 		{

 		if ( Card(i).iCID==NewCard(iNewCardsCount).iCID )

 			{

 			*aNewRCA=Card(i).iRCA;

 			NewCard(iNewCardsCount).iIndex=(i+1);

 			break;

 			}

 		}

 	if ( *aNewRCA==0 )

 		{

 		// Not seen this one before so get a new RCA for the card

 		NewCard(iNewCardsCount).iIndex=0;

 		__ASSERT_ALWAYS( (*aNewRCA=iOwningStack->iRCAPool.GetFreeRCA())!=0,DMMCSocket::Panic(DMMCSocket::EMMCNoFreeRCA) );

 		}

 	__KTRACE_OPT(KPBUS1, Kern::Printf("mca:adn: assigning new card %d rca 0x%04x", iNewCardsCount, TUint16(*aNewRCA) ));

 	OstTraceExt2( TRACE_INTERNALS, TMMCARDARRAY_ADDNEWCARD, "iNewCardsCount=%d; RCA=0x%04x", iNewCardsCount, (TUint) *aNewRCA );

 	NewCard(iNewCardsCount).iRCA=*aNewRCA;

 	iNewCardsCount++;

 	OstTraceFunctionExit1( TMMCARDARRAY_ADDNEWCARD_EXIT, this );

 	}

 TInt TMMCardArray::MergeCards(TBool aFirstPass)

 /**

  * This function places newly acquired cards from the new card array into free

  * slots of the main card array.

  * Returns KErrNotFound if not able to successfully place all the new cards.

  */

 	{

 	OstTraceFunctionEntryExt( TMMCARDARRAY_MERGECARDS_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mca:mc:%d,%d", aFirstPass, iNewCardsCount));

 	OstTrace1( TRACE_INTERNALS, TMMCARDARRAY_MERGECARDS1, "iNewCardsCount=%d", iNewCardsCount );

 	TUint i;	// New card index

 	TUint j;	// Main card index

 	// Only do this on first pass. Setup any new cards which were already there

 	if (aFirstPass)

 		{

 		for ( i=0 ; i<iNewCardsCount ; i++ )

 			{

 			__KTRACE_OPT(KPBUS1, Kern::Printf("-mca:fp,i=%d,idx=0x%x", i, NewCard(i).iIndex));

 			OstTraceExt2( TRACE_INTERNALS, TMMCARDARRAY_MERGECARDS2, "i=%d; Index=0x%x", i, NewCard(i).iIndex );

 			if( NewCard(i).iIndex != 0 ) // Signifies card was here before (iIndex has old slot number +1)

 				{

 				// Put it in the same slot as before

 				j=(NewCard(i).iIndex-1);

 				MoveCardAndLockRCA(NewCard(i),Card(j),(j+1));

 				}

 			}

 		}

 	for ( i=0,j=0 ; i<iNewCardsCount ; i++ )

 		{

 		__KTRACE_OPT(KPBUS1, Kern::Printf("-mca:i=%d,j=%d,rca=0x%4x", i, j, TUint16(NewCard(i).iRCA) ));

 		if ( NewCard(i).iRCA != 0 )

 			{

 			// Find a spare slot in main array for this new card

 			while ( Card(j).IsPresent() )

 				if ( ++j==iOwningStack->iMaxCardsInStack )

 				    {

 					OstTraceFunctionExitExt( TMMCARDARRAY_MERGECARDS_EXIT1, this, KErrNotFound );

 					return KErrNotFound;

 				    }

 			// Found a free slot; move the card info there

 			__KTRACE_OPT(KPBUS1, Kern::Printf("-mca:freej=%d,rca=0x%04x", j, TUint16(Card(j).iRCA) ));

 			OstTraceExt2( TRACE_INTERNALS, TMMCARDARRAY_MERGECARDS3, "j=%d; RCA=0x%04x", j, (TUint) (Card(j).iRCA) );

 			if ( Card(j).iRCA != 0 )

 				iOwningStack->iRCAPool.UnlockRCA(Card(j).iRCA);

 			__KTRACE_OPT(KPBUS1, Kern::Printf("merging new card %d to card %d dest index %d", i, j, j+1));

 			OstTraceExt3( TRACE_INTERNALS, TMMCARDARRAY_MERGECARDS4, "Merging new card %d to card %d; Destination index=%d", (TInt) i, (TInt) j, (TInt) j+1 );

 			MoveCardAndLockRCA(NewCard(i),Card(j),(j+1));

 			}

 		}

 	OstTraceFunctionExitExt( TMMCARDARRAY_MERGECARDS_EXIT2, this, KErrNone );

 	return KErrNone;

 	}

 void TMMCardArray::UpdateAcquisitions(TUint* aMaxClock)

 /**

  * Called when we have successfully stored a new set of cards in the card array.

  * This performs final initialisation of the card entries and determines the

  * maximum bus clock that can be employed - by checking the CSD of each card.

  */

 	{

 	OstTraceFunctionEntryExt( TMMCARDARRAY_UPDATEACQUISITIONS_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mca:uda"));

 	iCardsPresent=0;

 	TUint maxClk = iOwningStack->iMultiplexedBus ? 1 : 800000; // ???

 	for ( TUint i=0 ; i < (iOwningStack->iMaxCardsInStack) ; i++ )

 		{

 		if ( Card(i).IsPresent() )

 			{

 			// General initialisation

 			iCardsPresent++;

 			Card(i).iSetBlockLen=0;

 			Card(i).iLastCommand=ECmdSendStatus;

 			// Check each card present to determine appropriate bus clock

 			TUint maxTS = iOwningStack->MaxTranSpeedInKilohertz(Card(i));

 			if(iOwningStack->iMultiplexedBus)

 				{

 				if ( maxTS > maxClk )

 					maxClk = maxTS;

 				}

 			else

 				{

 				if ( maxTS < maxClk )

 					maxClk = maxTS;

 				}

 			}

 		}

 	// ??? Should also calculate here and return the data timeout and busy timeout 

 	// instead of relying on ASSP defaults.

 	*aMaxClock=maxClk;

 	OstTraceFunctionExit1( TMMCARDARRAY_UPDATEACQUISITIONS_EXIT, this );

 	}

 EXPORT_C void TMMCardArray::DeclareCardAsGone(TUint aCardNumber)

 /**

  * Clears up a card info object in the main card array

  */

 	{

 	OstTraceFunctionEntryExt( TMMCARDARRAY_DECLARECARDASGONE_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mca:dcag"));

 	// If we thought this one was present then mark it as not present

 	TMMCard& card = Card(aCardNumber);

 	if (card.IsPresent())

 		{

 		card.iIndex=0; // Mark card as not present

 		iCardsPresent--;

 		}

 	// If this card is in use by a session then flag that card has now gone

 	if( card.iUsingSessionP != NULL )

 		card.iUsingSessionP->iState |= KMMCSessStateCardIsGone;

 	card.iUsingSessionP=NULL;

 	card.iSetBlockLen=0;

 	card.iFlags=0; 		// Reset 'has password' and 'write protected' bit fields

 	card.iHighSpeedClock=0;

 	card.iBusWidth=1;

 	OstTraceFunctionExit1( TMMCARDARRAY_DECLARECARDASGONE_EXIT, this );

 	}

 // return this card's index in the array or KErrNotFound if not found

 TInt TMMCardArray::CardIndex(const TMMCard* aCard)

 	{

 	OstTraceFunctionEntryExt( TMMCARDARRAY_CARDINDEX_ENTRY, this );

 	TInt i;

 	for (i = KMaxMMCardsPerStack-1; i>= 0; i--)

 		{

 		if (iCards[i] == aCard)

 			break;

 		}

 	OstTraceFunctionExitExt( TMMCARDARRAY_CARDINDEX_EXIT, this, i );

 	return i;

 	}

 //	--------  class TMMCCommandDesc  --------

 EXPORT_C TInt TMMCCommandDesc::Direction() const

 /**

  * returns -1, 0 or +1 for DT directions read, none or write respectively

  */

 	{

 	OstTraceFunctionEntry1( TMMCCOMMANDDESC_DIRECTION_ENTRY, this );

 	TUint dir = iSpec.iDirection;

 	TInt result = dir;

 	TInt ret;

 	if( dir == 0 )

 	    {

 	    ret = 0;

 		OstTraceFunctionExitExt( TMMCCOMMANDDESC_DIRECTION_EXIT1, this, ret );

 		return ret;

 	    }

 	if( dir & KMMCCmdDirWBitArgument )

 		result = TUint(iArgument) >> (dir & KMMCCmdDirIndBitPosition);

 	if( dir & KMMCCmdDirNegate )

 		result = ~result;

 	ret = ((result&1)-1)|1;

 	OstTraceFunctionExitExt( TMMCCOMMANDDESC_DIRECTION_EXIT2, this, ret );

 	return ret;

 	}

 TBool TMMCCommandDesc::AdjustForBlockOrByteAccess(const DMMCSession& aSession)

 	{

 	OstTraceExt2(TRACE_FLOW, TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_ENTRY, "TMMCCommandDesc::AdjustForBlockOrByteAccess;Session ID=%d;this=%x", (TInt) aSession.SessionID(), (TUint) this);

 /**

  * The MMC session provides both block and byte based IO methods, all of which can

  * be used on both block and byte based MMC cards.  This method adjusts the command

  * arguments so that they match the underlying cards access mode.

  *

  * @return ETrue if the address is valid or successfully converted, EFalse otherwise

  */

 	TUint32 blockLength = BlockLength();

 	if(iTotalLength == 0	||

 	   blockLength == 0	||

 	   iTotalLength % KMMCardHighCapBlockSize != 0	||	// always aligned on 512 bytes

 	   blockLength % KMMCardHighCapBlockSize != 0)

 		{

 		OstTraceFunctionExitExt( TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_EXIT1, this, (TUint) EFalse );

 		return EFalse;

 		}

 	if(aSession.CardP()->IsHighCapacity())

 		{	

 		// high capacity (block-based) card

 		if((iFlags & KMMCCmdFlagBlockAddress) == 0)

 			{	

 			// The command arguments are using byte based addressing

 			//  - adjust to block-based addressing

 			if(iArgument % KMMCardHighCapBlockSize != 0)

 				{

 				// Block based media does not support misaligned access

 				OstTraceFunctionExitExt( TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_EXIT2, this, (TUint) EFalse );

 				return EFalse;

 				}

 			// adjust for block based access

 			iArgument = iArgument >> KMMCardHighCapBlockSizeLog2;

 			iFlags |= KMMCCmdFlagBlockAddress;

 			}

 		}

 	else

 		{

 		// standard (byte based) card

 		if((iFlags & KMMCCmdFlagBlockAddress) != 0)

 			{

 			// The command arguments are using block based addressing

 			//  - adjust to byte-based addressing

 			const TUint32 maxBlocks = 4 * 1024 * ((1024 * 1024) >> KMMCardHighCapBlockSizeLog2);

 			if(iArgument > maxBlocks)

 				{

 				// The address is out of range (>2G) - cannot convert

 				OstTraceFunctionExitExt( TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_EXIT3, this, (TUint) EFalse );

 				return EFalse;

 				}

 			// adjust for byte-based access

 			iArgument = iArgument << KMMCardHighCapBlockSizeLog2;

 			iFlags &= ~KMMCCmdFlagBlockAddress;

 			}

 		else if(iArgument % KMMCardHighCapBlockSize != 0)

 			{

 			// byte addressing, unaligned address

 			OstTraceFunctionExitExt( TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_EXIT4, this, (TUint) EFalse );

 			return EFalse;

 			}

 		}

 	OstTraceFunctionExitExt( TMMCCOMMANDDESC_ADJUSTFORBLOCKORBYTEACCESS_EXIT5, this, (TUint) ETrue );

 	return ETrue;

 	}

 void TMMCCommandDesc::Dump(TUint8* aResponseP, TMMCErr aErr)

 	{

 	Kern::Printf("------------------------------------------------------------------");

 	Kern::Printf("CMD %02d(0x%08x) - ",TUint(iCommand),TUint(iArgument));

 	switch(iCommand)

 		{

 		case 0  : Kern::Printf("                   | GO_IDLE_STATE");			break;

 		case 1  : Kern::Printf("                   | SEND_OP_COND");			break;

 		case 2  : Kern::Printf("                   | ALL_SEND_CID");			break;

 		case 3  : Kern::Printf("                   | SET_RELATIVE_ADDR");		break;

 		case 4  : Kern::Printf("                   | SET_DSR");					break;

 		case 5  : Kern::Printf("                   | SLEEP/AWAKE");				break;

 		case 6  : Kern::Printf("                   | SWITCH");					break;

 		case 7  : Kern::Printf("                   | SELECT/DESELECT_CARD");	break;

 		case 8  : Kern::Printf("                   | SEND_EXT_CSD");			break;

 		case 9  : Kern::Printf("                   | SEND_CSD");				break;

 		case 10 : Kern::Printf("                   | SEND_CID");				break;

 		case 11 : Kern::Printf("                   | READ_DAT_UNTIL_STOP");		break;

 		case 12 : Kern::Printf("                   | STOP_TRANSMISSION");		break;

 		case 13 : Kern::Printf("                   | SEND_STATUS");				break;

 		case 14 : Kern::Printf("                   | BUSTEST_R");				break;

 		case 15 : Kern::Printf("                   | GO_INACTIVE_STATE");		break;

 		case 16 : Kern::Printf("                   | SET_BLOCKLEN");			break;

 		case 17 : Kern::Printf("                   | READ_SINGLE_BLOCK");		break;

 		case 18 : Kern::Printf("                   | READ_MULTIPLE_BLOCK");		break;

 		case 19 : Kern::Printf("                   | BUSTEST_W");				break;

 		case 20 : Kern::Printf("                   | WRITE_DAT_UNTIL_STOP");	break;

 		case 23 : Kern::Printf("                   | SET_BLOCK_COUNT");			break;

 		case 24 : Kern::Printf("                   | WRITE_BLOCK");				break;

 		case 25 : Kern::Printf("                   | WRITE_MULTIPLE_BLOCK");	break;

 		case 26 : Kern::Printf("                   | PROGRAM_CID");				break;

 		case 27 : Kern::Printf("                   | PROGRAM_CSD");				break;

 		case 28 : Kern::Printf("                   | SET_WRITE_PROT");			break;

 		case 29 : Kern::Printf("                   | CLR_WRITE_PROT");			break;

 		case 30 : Kern::Printf("                   | SEND_WRITE_PROT");			break;

 		case 32 : Kern::Printf("                   | ERASE_WR_BLK_START");		break;	// SD

 		case 33 : Kern::Printf("                   | ERASE_WR_BLK_END");		break;	// SD

 		case 35 : Kern::Printf("                   | ERASE_GROUP_START");		break;

 		case 36 : Kern::Printf("                   | ERASE_GROUP_END");			break;

 		case 38 : Kern::Printf("                   | ERASE");					break;

 		case 39 : Kern::Printf("                   | FAST_IO");					break;

 		case 40 : Kern::Printf("                   | GO_IRQ_STATE");			break;

 		case 42 : Kern::Printf("                   | LOCK_UNLOCK");				break;

 		case 55 : Kern::Printf("                   | APP_CMD");					break;

 		case 56 : Kern::Printf("                   | GEN_CMD");					break;

 		default : Kern::Printf("                   | *** UNKNOWN COMMAND ***"); break;

 		}

 	switch(iSpec.iResponseType)

 		{

 		case ERespTypeNone:		Kern::Printf("               RSP - NONE");		break;

 		case ERespTypeUnknown:	Kern::Printf("               RSP - UNKNOWN");	break;

 		case ERespTypeR1:		Kern::Printf("               RSP - R1");		break;

 		case ERespTypeR1B:		Kern::Printf("               RSP - R1b");		break;

 		case ERespTypeR2:		Kern::Printf("               RSP - R2");		break;

 		case ERespTypeR3:		Kern::Printf("               RSP - R3");		break;

 		case ERespTypeR4:		Kern::Printf("               RSP - R4");		break;

 		case ERespTypeR5:		Kern::Printf("               RSP - R5");		break;

 		case ERespTypeR6:		Kern::Printf("               RSP - R6");		break;

 		default :				Kern::Printf("               RSP - *** UNKNOWN RESPONSE ***"); break;

 		}

 	switch(iSpec.iResponseLength)

 		{

 		case 0  :																				break;

 		case 4  : Kern::Printf("                   | 0x%08x", TMMC::BigEndian32(aResponseP));	break;

 		case 16 : Kern::Printf("                   | 0x%08x 0x%08x 0x%08x 0x%08x", ((TUint32*)aResponseP)[0], ((TUint32*)aResponseP)[1], ((TUint32*)aResponseP)[2], ((TUint32*)aResponseP)[3]); break;

 		default : Kern::Printf("                   | *** RESPONSE NOT PARSED ***");				break;

 		}

 									  Kern::Printf("               ERR - 0x%08x", aErr);

 	if(aErr & KMMCErrResponseTimeOut) Kern::Printf("                   | KMMCErrResponseTimeOut");

 	if(aErr & KMMCErrDataTimeOut)	  Kern::Printf("                   | KMMCErrDataTimeOut");

 	if(aErr & KMMCErrBusyTimeOut)	  Kern::Printf("                   | KMMCErrBusyTimeOut");

 	if(aErr & KMMCErrBusTimeOut)	  Kern::Printf("                   | KMMCErrBusTimeOut");

 	if(aErr & KMMCErrTooManyCards)	  Kern::Printf("                   | KMMCErrTooManyCards");

 	if(aErr & KMMCErrResponseCRC)	  Kern::Printf("                   | KMMCErrResponseCRC");

 	if(aErr & KMMCErrDataCRC)		  Kern::Printf("                   | KMMCErrDataCRC");

 	if(aErr & KMMCErrCommandCRC)	  Kern::Printf("                   | KMMCErrCommandCRC");

 	if(aErr & KMMCErrStatus)		  Kern::Printf("                   | KMMCErrStatus");

 	if(aErr & KMMCErrNoCard)		  Kern::Printf("                   | KMMCErrNoCard");

 	if(aErr & KMMCErrBrokenLock)	  Kern::Printf("                   | KMMCErrBrokenLock");

 	if(aErr & KMMCErrPowerDown)		  Kern::Printf("                   | KMMCErrPowerDown");

 	if(aErr & KMMCErrAbort)			  Kern::Printf("                   | KMMCErrAbort");

 	if(aErr & KMMCErrStackNotReady)	  Kern::Printf("                   | KMMCErrStackNotReady");

 	if(aErr & KMMCErrNotSupported)	  Kern::Printf("                   | KMMCErrNotSupported");

 	if(aErr & KMMCErrHardware)		  Kern::Printf("                   | KMMCErrHardware");

 	if(aErr & KMMCErrBusInconsistent) Kern::Printf("                   | KMMCErrBusInconsistent");

 	if(aErr & KMMCErrBypass)		  Kern::Printf("                   | KMMCErrBypass");

 	if(aErr & KMMCErrInitContext)	  Kern::Printf("                   | KMMCErrInitContext");

 	if(aErr & KMMCErrArgument)		  Kern::Printf("                   | KMMCErrArgument");

 	if(aErr & KMMCErrSingleBlock)	  Kern::Printf("                   | KMMCErrSingleBlock");

 	if(aErr & KMMCErrUpdPswd)		  Kern::Printf("                   | KMMCErrUpdPswd");

 	if(aErr & KMMCErrLocked)		  Kern::Printf("                   | KMMCErrLocked");

 	if(aErr & KMMCErrNotFound)		  Kern::Printf("                   | KMMCErrNotFound");

 	if(aErr & KMMCErrAlreadyExists)	  Kern::Printf("                   | KMMCErrAlreadyExists");

 	if(aErr & KMMCErrGeneral)		  Kern::Printf("                   | KMMCErrGeneral");

 	if(iSpec.iResponseType == ERespTypeR1 || iSpec.iResponseType == ERespTypeR1B)

 		{

 		const TUint32 stat = TMMC::BigEndian32(aResponseP);

 											 Kern::Printf("              STAT - 0x%08x", stat);

 		if(stat & KMMCStatAppCmd)			 Kern::Printf("                   | KMMCStatAppCmd");

 		if(stat & KMMCStatSwitchError)		 Kern::Printf("                   | KMMCStatSwitchError");

 		if(stat & KMMCStatReadyForData)		 Kern::Printf("                   | KMMCStatReadyForData");

 		if(stat & KMMCStatCurrentStateMask){ Kern::Printf("                   | KMMCStatCurrentStateMask");

 											 const TMMCardStateEnum cardState = (TMMCardStateEnum)(stat & KMMCStatCurrentStateMask);

 											 switch (cardState){

 												 case ECardStateIdle  : Kern::Printf("                     | ECardStateIdle"); break;

 												 case ECardStateReady : Kern::Printf("                     | ECardStateReady"); break;

 												 case ECardStateIdent : Kern::Printf("                     | ECardStateIdent"); break;

 												 case ECardStateStby  : Kern::Printf("                     | ECardStateStby"); break;

 												 case ECardStateTran  : Kern::Printf("                     | ECardStateTran"); break;

 												 case ECardStateData  : Kern::Printf("                     | ECardStateData"); break;

 												 case ECardStateRcv   : Kern::Printf("                     | ECardStateRcv"); break;

 												 case ECardStatePrg   : Kern::Printf("                     | ECardStatePrg"); break;

 												 case ECardStateDis   : Kern::Printf("                     | ECardStateDis"); break;

 												 case ECardStateBtst  : Kern::Printf("                     | ECardStateBtst"); break;

 												 case ECardStateSlp   : Kern::Printf("                     | ECardStateSlp"); break;

 												 default   	 		  : Kern::Printf("                     | ECardStateUnknown"); break;

 											 }

 										   }

 		if(stat & KMMCStatEraseReset)		 Kern::Printf("                   | KMMCStatEraseReset");

 		if(stat & KMMCStatCardECCDisabled)	 Kern::Printf("                   | KMMCStatCardECCDisabled");

 		if(stat & KMMCStatWPEraseSkip)		 Kern::Printf("                   | KMMCStatWPEraseSkip");

 		if(stat & KMMCStatErrCSDOverwrite)	 Kern::Printf("                   | KMMCStatErrCSDOverwrite");

 		if(stat & KMMCStatErrOverrun)		 Kern::Printf("                   | KMMCStatErrOverrun");

 		if(stat & KMMCStatErrUnderrun)		 Kern::Printf("                   | KMMCStatErrUnderrun");

 		if(stat & KMMCStatErrUnknown)		 Kern::Printf("                   | KMMCStatErrUnknown");

 		if(stat & KMMCStatErrCCError)		 Kern::Printf("                   | KMMCStatErrCCError");

 		if(stat & KMMCStatErrCardECCFailed)  Kern::Printf("                   | KMMCStatErrCardECCFailed");

 		if(stat & KMMCStatErrIllegalCommand) Kern::Printf("                   | KMMCStatErrIllegalCommand");

 		if(stat & KMMCStatErrComCRCError)	 Kern::Printf("                   | KMMCStatErrComCRCError");

 		if(stat & KMMCStatErrLockUnlock)	 Kern::Printf("                   | KMMCStatErrLockUnlock");

 		if(stat & KMMCStatCardIsLocked)		 Kern::Printf("                   | KMMCStatCardIsLocked");

 		if(stat & KMMCStatErrWPViolation)	 Kern::Printf("                   | KMMCStatErrWPViolation");

 		if(stat & KMMCStatErrEraseParam)	 Kern::Printf("                   | KMMCStatErrEraseParam");

 		if(stat & KMMCStatErrEraseSeqError)  Kern::Printf("                   | KMMCStatErrEraseSeqError");

 		if(stat & KMMCStatErrBlockLenError)  Kern::Printf("                   | KMMCStatErrBlockLenError");

 		if(stat & KMMCStatErrAddressError)	 Kern::Printf("                   | KMMCStatErrAddressError");

 		if(stat & KMMCStatErrOutOfRange)	 Kern::Printf("                   | KMMCStatErrOutOfRange");

 		}

 	Kern::Printf("                   -----------------------------------------------");

 	}

 //	--------  class TMMCRCAPool  --------

 TRCA TMMCRCAPool::GetFreeRCA()

 /**

  * Returns a free RCA number from the pool or zero if none is available

  */

 	{

 	OstTraceFunctionEntry1( TMMCRCAPOOL_GETFREERCA_ENTRY, this );

 	TUint32 seekm = (iPool | iLocked) + 1;

 	iPool |= (seekm & ~iLocked);

 	TUint16 ret;

 	if( (seekm & 0xFFFFFFFF) == 0 )

 	    {

 	    ret = 0;

 		OstTraceFunctionExitExt( TMMCRCAPOOL_GETFREERCA_EXIT1, this, (TUint) ret);

 		return ret;

 	    }

 	TUint16 pos = 1;

 	if ((seekm & 0xFFFF) == 0)	{ seekm >>= 16;	pos = 17; }

 	if ((seekm & 0xFF) == 0)	{ seekm >>= 8;	pos += 8; }

 	if ((seekm & 0xF) == 0)		{ seekm >>= 4;	pos += 4; }

 	if ((seekm & 0x3) == 0)		{ seekm >>= 2;	pos += 2; }

 	if ((seekm & 0x1) == 0)		pos++;

 	// Multiply return value by 257 so that 1 is never returned.  (0x0001 is the default RCA value.)

 	// The RCA integer value is divided by 257 in LockRCA() and UnlockRCA() to compensate

 	// for this adjustment.  These functions are only ever called in this file with the iRCA

 	// field of a TMMCard object, and not with arbitrary values.

 	// The iRCA field itself is only assigned values from iNewCards[] or zero.  iNewCards

 	// in turn is fed values from this function, in DMMCStack::CIMUpdateAcqSM() / EStSendCIDIssued.

 	ret = TUint16(pos << 8 | pos);

 	OstTraceFunctionExitExt( TMMCRCAPOOL_GETFREERCA_EXIT2, this, (TUint) ret);

 	return ret;

 	}

 //	--------  class TMMCSessRing  --------

 TMMCSessRing::TMMCSessRing()

 /**

  * Constructor

  */

 	: iPMark(NULL),iPoint(NULL),iPrevP(NULL),iSize(0)

 	{OstTraceFunctionEntry1( TMMCSESSRING_TMMCSESSRING_ENTRY, this );}

 void TMMCSessRing::Erase()

 /**

  * Erases all the ring content

  */

 	{

 	OstTraceFunctionEntry1( TMMCSESSRING_ERASE_ENTRY, this );

 	iPMark = iPoint = iPrevP = NULL; iSize = 0;

 	OstTraceFunctionExit1( TMMCSESSRING_ERASE_EXIT, this );

 	}

 DMMCSession* TMMCSessRing::operator++(TInt)

 /**

  * Post increment of Point

  */

 	{

 	if( iPoint == NULL )

 		return( NULL );

 	if( (iPrevP=iPoint) == iPMark )

 		iPoint = NULL;

 	else

 		iPoint = iPoint->iLinkP;

 	return( iPrevP );

 	}

 TBool TMMCSessRing::Point(DMMCSession* aSessP)

 /**

  * Finds aSessP and sets Point to that position

  */

 	{

 	OstTraceFunctionEntryExt( TMMCSESSRING_POINT_ENTRY, this );

 	Point();

 	while( iPoint != NULL )

 		if( iPoint == aSessP )

 		    {

 			OstTraceFunctionExitExt( TMMCSESSRING_POINT_EXIT1, this, (TUint) ETrue );

 			return ETrue;

 		    }

 		else

 			this->operator++(0);

 	OstTraceFunctionExitExt( TMMCSESSRING_POINT_EXIT2, this, (TUint) EFalse );

 	return EFalse;

 	}

 void TMMCSessRing::Add(DMMCSession* aSessP)

 /**

  * Inserts aSessP before Marker. Point is moved into the Marker position.

  */

 	{

 	OstTraceFunctionEntryExt( TMMCSESSRING_ADD1_ENTRY, this );

 	if( iSize == 0 )

 		{

 		iPMark = iPrevP = iPoint = aSessP;

 		aSessP->iLinkP = aSessP;

 		iSize = 1;

 		OstTraceFunctionExit1( TMMCSESSRING_ADD1_EXIT1, this );

 		return;

 		}

 	iPoint = iPMark->iLinkP;

 	iPMark->iLinkP = aSessP;

 	aSessP->iLinkP = iPoint;

 	iPMark = iPrevP = aSessP;

 	iSize++;

 	OstTraceFunctionExit1( TMMCSESSRING_ADD1_EXIT2, this );

 	}

 void TMMCSessRing::Add(TMMCSessRing& aRing)

 /**

  * Inserts aRing before Marker. Point is moved into the Marker position.

  * aRing Marker becomes the fisrt inserted element.

  * Erases aRing.

  */

 	{

 	OstTraceFunctionEntry1( TMMCSESSRING_ADD2_ENTRY, this );

 	Point();

 	if( aRing.iSize == 0 )

 	    {

 		OstTraceFunctionExit1( TMMCSESSRING_ADD2_EXIT1, this );

 		return;

 	    }

 	if( iSize == 0 )

 		{

 		iPrevP = iPMark = aRing.iPMark;

 		iPoint = iPrevP->iLinkP;

 		iSize = aRing.iSize;

 		}

 	else

 		{

 		iPrevP->iLinkP = aRing.iPMark->iLinkP;

 		iPMark = iPrevP = aRing.iPMark;

 		iPrevP->iLinkP = iPoint;

 		iSize += aRing.iSize;

 		}

 	aRing.Erase();

 	OstTraceFunctionExit1( TMMCSESSRING_ADD2_EXIT2, this );

 	}

 DMMCSession* TMMCSessRing::Remove()

 /**

  * Removes an element pointed to by Point.

  * Point (and possibly Marker) move forward as in operator++

  */

 	{

 	OstTraceFunctionEntry1( TMMCSESSRING_REMOVE1_ENTRY, this );

 	DMMCSession* remS = iPrevP;

 	if( iSize < 2 )

 		Erase();

 	else

 		{

 		remS = remS->iLinkP;

 		iPrevP->iLinkP = remS->iLinkP;

 		iSize--;

 		if( iPoint != NULL )

 			iPoint = iPrevP->iLinkP;

 		if( iPMark == remS )

 			{

 			iPMark = iPrevP;

 			iPoint = NULL;

 			}

 		}

 	OstTraceFunctionExitExt( TMMCSESSRING_REMOVE1_EXIT, this, ( TUint )( remS ) );

 	return remS;

 	}

 void TMMCSessRing::Remove(DMMCSession* aSessP)

 /**

  * Removes a specified session from the ring

  */

 	{

 	OstTraceFunctionEntryExt( TMMCSESSRING_REMOVE2_ENTRY, this );

 	if( Point(aSessP) )

 		Remove();

 	else

 		DMMCSocket::Panic(DMMCSocket::EMMCSessRingNoSession);

 	OstTraceFunctionExit1( TMMCSESSRING_REMOVE2_EXIT, this );

 	}

 //	--------  class TMMCStateMachine  --------

 /**

 Removes all state from the state machine.

 It also resets the stack and the exit code.

 */

 EXPORT_C void TMMCStateMachine::Reset()

 	{

 	OstTraceFunctionEntry1( TMMCSTATEMACHINE_RESET_ENTRY, this );

 	iAbort = EFalse;

 	iSP = 0; iExitCode = 0;

 	iStack[0].iState = 0; iStack[0].iTrapMask = 0;

 	OstTraceFunctionExit1( TMMCSTATEMACHINE_RESET_EXIT, this );

 	}

 /**

 The state machine dispatcher.

 @return The MultiMediaCard error code. 

 */

 EXPORT_C TMMCErr TMMCStateMachine::Dispatch()

 	{

 	OstTraceFunctionEntry1( TMMCSTATEMACHINE_DISPATCH_ENTRY, this );

 	// If a state machine returns non-zero, i.e. a non-empty error set, then the second

 	// inner while loop is broken.  The errors are thrown like an exception where the

 	// stack is unravelled until it reaches a state machine which can handle at least

 	// one of the error codes, else this function returns with the exit code or'd with

 	// KMMCErrBypass.  If the state machine returns zero, then this function returns

 	// zero if iSuspend is set, i.e., if the stack is waiting on an asynchronous event.

 	// If suspend is not set, then the next state machine is called.  This may be the

 	// same as the current state machine, or its caller if the current state machine

 	// ended called Pop() before exiting, e.g., via SMF_END.

 	while( iSP >= 0 && !iAbort )

 		{

 		// If there is an un-trapped error, wind back down the stack, either

 		// to the end of the stack or until the error becomes trapped.

 		while( iSP >= 0 && (iExitCode & ~iStack[iSP].iTrapMask) != 0 )

 			iSP--;

 		iExitCode &= ~KMMCErrBypass;

 		if ( iExitCode )

 			{

 			__KTRACE_OPT(KPBUS1,Kern::Printf(">MMC:Err %x",iExitCode));

 			OstTrace1( TRACE_INTERNALS, TMMCSTATEMACHINE_DISPATCH, "iExitCode=0x%x", iExitCode );

 			}

 		while( iSP >= 0 && !iAbort )

 			{

 			__KTRACE_OPT(KPBUS1,Kern::Printf("-msm:dsp:%02x:%08x.%02x",iSP, TUint32(iStack[iSP].iFunction), State()));

 			OstTraceExt3( TRACE_INTERNALS, TMMCSTATEMACHINE_DISPATCH2, "iSP=%d; iStack[iSP].iFunction=0x%08x; State=0x%02x", (TInt) iSP, (TUint) iStack[iSP].iFunction, (TUint) State() );

 			iSuspend = ETrue;

 			const TMMCErr signal = iStack[iSP].iFunction(iContextP);

 			if (signal)

 				{

 				iExitCode = signal;

 				break;

 				}

 			if( iSuspend )

 				{

 				__KTRACE_OPT(KPBUS1,Kern::Printf("<msm:dsp:exitslp"));

 				OstTraceFunctionExit1( TMMCSTATEMACHINE_DISPATCH_EXIT1, this );

 				return(0);

 				}

 			}

 		}

 	__KTRACE_OPT(KPBUS1,Kern::Printf("<msm:dsp:exit%08x", iExitCode));

 	OstTraceFunctionExit1( TMMCSTATEMACHINE_DISPATCH_EXIT2, this );

 	return( KMMCErrBypass | iExitCode );

 	}

 /**

 Pushes another state machine entry onto the stack.

 Typically, this is invoked using one of the macros:

 SMF_CALL, SMF_CALLWAIT, SMF_INVOKES, SMF_INVOKEWAITS 

 @param anEntry  The state machine function to be run; this will start at

                 the initial state (EStBegin), with no exception handling defined.

 @param aSuspend Indicates whether the state machine is to block on return to the dispatcher;

                 Specify ETrue to block; EFalse not to block.

                 EFalse is the default, if not explicitly stated.

 @return KMMCErrNone

 @panic PBUS-MMC 0 if the maximum depth of nested state machine entries is being exeeded.

 @see SMF_CALL

 @see SMF_CALLWAIT

 @see SMF_INVOKES

 @see SMF_INVOKEWAITS 

 */

 EXPORT_C TMMCErr TMMCStateMachine::Push(TMMCErr (*anEntry)(TAny*), TBool aSuspend)

 	{

 	OstTraceFunctionEntry1( TMMCSTATEMACHINE_PUSH_ENTRY, this );

 	iSP++;

 	__ASSERT_ALWAYS(TUint(iSP)<KMaxMMCMachineStackDepth,

 		DMMCSocket::Panic(DMMCSocket::EMMCMachineStack));

 	iStack[iSP].iFunction = anEntry;

 	iStack[iSP].iState = 0;

 	iStack[iSP].iTrapMask = 0;

 	if( !aSuspend )

 		iSuspend = EFalse;

 	OstTraceFunctionExit1( TMMCSTATEMACHINE_PUSH_EXIT, this );

 	return 0;

 	}

 /**

 Jumps to the specified state machine function in the current state machine entry.

 @param anEntry  The state machine function to be run; this will start at

                 the initial state (EStBegin), with no exception handling defined.

 @param aSuspend Indicates whether the state machine is to block on return to the dispatcher;

                 Specify ETrue to block; EFalse not to block.

                 EFalse is the default, if not explicitly stated.

 @return KMMCErrNone

 */

 EXPORT_C TMMCErr TMMCStateMachine::Jump(TMMCErr (*anEntry)(TAny*), TBool aSuspend)

 	{

 	OstTraceFunctionEntry1( TMMCSTATEMACHINE_JUMP_ENTRY, this );

 	iStack[iSP].iFunction = anEntry;

 	iStack[iSP].iState = 0;

 	iStack[iSP].iTrapMask = 0;

 	if( !aSuspend )

 		iSuspend = EFalse;

 	OstTraceFunctionExit1( TMMCSTATEMACHINE_JUMP_EXIT, this );

 	return 0;

 	}

 //	--------  class DMMCStack  --------

 #pragma warning( disable : 4355 )	// this used in initializer list

 EXPORT_C DMMCStack::DMMCStack(TInt /*aBus*/, DMMCSocket* aSocket)

 /**

  * Constructs a DMMCStack object

  * @param aBus Unused

  * @param aSocket A pointer to the associated socket.

  */

 	: iWorkSet(),

 	iReadyQueue(),

 	iEntryQueue(),

 	iStackDFC(DMMCStack::StackDFC, this, 1),

 	iSelectedCard(TUint16(~0)),

 	iSocket(aSocket),

 	iStackSession(NULL),

 	iAutoUnlockSession(TMMCCallBack(AutoUnlockCBST, this)),

 	iInitState(EISPending),

 	iInitialise(ETrue),

 	iCurrentDSR(),

 	iConfig(),

 	iRCAPool(),

 	iMasterConfig()

 	{

 //	iStackState(0),

 //	iLockingSessionP(NULL),

 //	iAttention(EFalse),

 //	iAbortReq(EFalse),

 //	iCompReq(EFalse),

 //	iDoorOpened(EFalse),

 //	iPoweredUp(EFalse),

 //	iDFCRunning(EFalse),

 //	iAbortAll(EFalse),

 //	iAllExitCode(0),

 //	iSessionP(NULL),

 //	iCurrentOpRange(0),

 //	iCardsPresent(0),

 //	iMaxCardsInStack(0)

 	}

 #pragma warning( default : 4355 )

 EXPORT_C TInt DMMCStack::Init()

 /**

  * Initialises the generic MMC stack.

  * @return KErrNone if successful, standard error code otherwise.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_INIT_ENTRY, this );

 	// allocate and initialize session object

 	if ((iStackSession = AllocSession(TMMCCallBack(StackSessionCBST, this))) == 0)

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_INIT_EXIT1, this, KErrNoMemory );

 		return KErrNoMemory;

 	    }

 	// create helper class

 	if ((iBody = new DBody(*this)) == NULL)

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_INIT_EXIT2, this, KErrNoMemory );

 		return KErrNoMemory;

 	    }

 	iStackSession->SetStack(this);

 	iStackDFC.SetDfcQ(&iSocket->iDfcQ);

 	// Get the maximal number of cards from ASSP layer

 	iMaxCardsInStack = iSocket->TotalSupportedCards();

 	if ( iMaxCardsInStack > KMaxMMCardsPerStack )

 		iMaxCardsInStack=KMaxMMCardsPerStack;

 	TInt r = iCardArray->AllocCards();

 	OstTraceFunctionExitExt( DMMCSTACK_INIT_EXIT3, this, r );

 	return r;

 	}

 EXPORT_C void DMMCStack::PowerUpStack()

 /**

  * Enforce stack power-up and initialisation.

  * This is an asynchronous operation, which calls DMMCSocket::PowerUpSequenceComplete upon completion.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_POWERUPSTACK_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:pus"));

 	if (iPSLBuf == NULL)

 		{

 		GetBufferInfo(&iPSLBuf, &iPSLBufLen);

 		iMinorBufLen = KMinMinorBufSize;

 		}

 	ReportPowerDown();							// ensure power will be switch on regardless

 	Scheduler( iInitialise );

 	OstTraceFunctionExit1( DMMCSTACK_POWERUPSTACK_EXIT, this );

 	}

 void DMMCStack::QSleepStack()

 /**

  * Schedules a session to place media in Sleep State

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_QSLEEPSTACK_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:qsleep"));

 	Scheduler( iSleep );

 	OstTraceFunctionExit1( DMMCSTACK_QSLEEPSTACK_EXIT, this );

 	}

 EXPORT_C void DMMCStack::PowerDownStack()

 /**

  * Enforce stack power down.

  * Clients generally shouldn't need to concern themselves with powering down a stack 

  * unless they specifically need to perform a power reset of a card.  If a driver fails to 

  * open then normal practise is for that driver to leave the card powered so that any subsequent 

  * driver which may attempt to open immediately after this failed attempt won't have to re-power the card. 

  * If no driver successfully opens on the card then the Controllers inactivity/not in use 

  * timeout system can be left to power it down.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_POWERDOWNSTACK_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:pds"));

 	ReportPowerDown();

 	iInitState = EISPending;

 	DoPowerDown();

 	TBool cardRemoved = (iStackState & KMMCStackStateCardRemoved);

 	for (TUint i=0;i<iMaxCardsInStack;i++)

 		{

 		TMMCard& card = iCardArray->Card(i);

 		card.SetBusWidth(1);

 		card.SetHighSpeedClock(0);

 		if (cardRemoved)

 			{

 		    iCardArray->DeclareCardAsGone(i);

 			}

 		else

 			{

 			// set the locked bit if the card has a password - need to do this 

 			// now that RLocalDrive::Caps() no longer powers up the stack

 			if (card.HasPassword())

 				{

 				TMapping* pmp = iSocket->iPasswordStore->FindMappingInStore(card.CID());

 				if (!pmp || pmp->iState != TMapping::EStValid)

 					{

 					*((TUint32*) &card.iStatus) |= KMMCStatCardIsLocked;

 					}

 				}

 			// Remove card state flags, after a power cycle all cards are in idle state

 			*((TUint32*) &card.iStatus) &= ~KMMCStatCurrentStateMask;

 			}

 		}

 	if (cardRemoved)

 	    iStackState &= ~KMMCStackStateCardRemoved;

 	iSocket->iVcc->SetState(EPsuOff);

 	if (iSocket->iVccCore)

 		iSocket->iVccCore->SetState(EPsuOff);

 	// Cancel timers, reset ASSP, cancel stack DFC & remove session from workset 

 	// to ensure stack doesn't wake up again & attempt to dereference iSessionP

  	if (iSessionP)

 		Abort(iSessionP);

 	iStackDFC.Cancel();

 	// The stack may have powered down while attempting to power up (e.g. because a card has not responded), 

 	// so ensure stack doesn't attempt to initialize itself again until next PowerUpStack()

 	iInitialise = EFalse;

 	iStackState &= ~(KMMCStackStateInitInProgress | KMMCStackStateInitPending | KMMCStackStateBusInconsistent | KMMCStackStateWaitingDFC);

 	iSessionP = NULL;

 	OstTraceFunctionExit1( DMMCSTACK_POWERDOWNSTACK_EXIT, this );

 	}

 //

 // DMMCStack:: --- Stack Scheduler and its supplementary functions ---

 //

 DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedGetOnDFC()

 /**

  * Initiates stack DFC. Returns either Continue or Loop.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDGETONDFC_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sgd"));

 	if( iDFCRunning )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDGETONDFC_EXIT1, this, (TInt) ESchedContinue);

 		return ESchedContinue;

 	    }

 	if( (iStackState & KMMCStackStateWaitingDFC) == 0 )

 		{

 		__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sgd:q"));

 		iStackState |= KMMCStackStateWaitingDFC;

 		if (NKern::CurrentContext()==NKern::EInterrupt)

 			iStackDFC.Add();

 		else

 			iStackDFC.Enque();

 		}

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDGETONDFC_EXIT2, this, (TInt) ESchedLoop);

 	return ESchedLoop;

 	}

 void DMMCStack::SchedSetContext(DMMCSession* aSessP)

 /**

  * Sets up the specified session as the current session.

  * Invoked by JobChooser and Initialiser.

  * @param aSessP A pointer to the session.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDSETCONTEXT_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:ssc"));

 	if( (iStackState & (KMMCStackStateInitPending|KMMCStackStateBusInconsistent)) != 0 &&

 		aSessP->iSessionID != ECIMInitStack )

 		{

 		iInitialise = ETrue;

 		OstTraceFunctionExit1( DMMCSTACK_SCHEDSETCONTEXT_EXIT1, this );

 		return;

 		}

 	if( iSessionP != aSessP )

 		{

 		iStackState |= KMMCStackStateReScheduled;

 		MergeConfig( aSessP );

 		if( aSessP->iSessionID == ECIMInitStack )

 			iInitialise = ETrue;

 		else

 			if( InitStackInProgress() )

 				MarkComplete( aSessP, KMMCErrStackNotReady );

 			else

 				if( aSessP->iBrokenLock )

 					MarkComplete( aSessP, KMMCErrBrokenLock );

 		iSessionP = aSessP;

 		}

 	iSessionP->iState &= ~KMMCSessStateDoReSchedule;

 	OstTraceFunctionExit1( DMMCSTACK_SCHEDSETCONTEXT_EXIT2, this );

 	}

 void DMMCStack::SchedDoAbort(DMMCSession* aSessP)

 /**

  * Aborts asynchronous activities of a session aSessP

  * @param aSessP A pointer to the session to be aborted.

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_SCHEDDOABORT_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sda"));

 #ifdef __EPOC32__

 	if( aSessP->iBlockOn & KMMCBlockOnPollTimer )

 		aSessP->iPollTimer.Cancel();

 	if( aSessP->iBlockOn & KMMCBlockOnRetryTimer )

 		aSessP->iRetryTimer.Cancel();

 	if( aSessP->iBlockOn & KMMCBlockOnPgmTimer )

 		aSessP->iProgramTimer.Cancel();

 #endif	// #ifdef __EPOC32__

 	if( aSessP->iBlockOn & KMMCBlockOnWaitToLock )

 		iStackState &= ~KMMCStackStateWaitingToLock;

 	if( aSessP->iBlockOn & (KMMCBlockOnASSPFunction | KMMCBlockOnInterrupt | KMMCBlockOnDataTransfer) )

 		ASSPReset();

 	if( (aSessP->iState & (KMMCSessStateInProgress|KMMCSessStateCritical)) ==

 		 (KMMCSessStateInProgress|KMMCSessStateCritical) )

 		iStackState |= KMMCStackStateInitPending;

 	(void)__e32_atomic_and_ord32(&aSessP->iBlockOn, ~(KMMCBlockOnPollTimer | KMMCBlockOnRetryTimer |

 						  							  KMMCBlockOnWaitToLock | KMMCBlockOnASSPFunction | 

 						  							  KMMCBlockOnInterrupt | KMMCBlockOnDataTransfer) );

 	OstTraceFunctionExit1( DMMCSTACK_SCHEDDOABORT_EXIT, this );

 	}

 DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedResolveStatBlocks(DMMCSession* aSessP)

 /**

  * Checks static blocking conditions and removes them as necessary

  * @param aSessP A pointer to the session.

  * @return EschedContinue or ESchedLoop (if scheduler is to be restarted)

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_SCHEDRESOLVESTATBLOCKS_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:srsb"));

 	if( (aSessP->iBlockOn & KMMCBlockOnCardInUse) && aSessP->iCardP->iUsingSessionP == NULL )

 		aSessP->SynchUnBlock( KMMCBlockOnCardInUse );

 	if( (aSessP->iBlockOn & KMMCBlockOnWaitToLock) && iWorkSet.Size() == 1 )

 		{

 		// ECIMLockStack processed here

 		iLockingSessionP = aSessP;					// in this order

 		iStackState &= ~KMMCStackStateWaitingToLock;

 		aSessP->SynchUnBlock( KMMCBlockOnWaitToLock );

 		MarkComplete( aSessP, KMMCErrNone );

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDRESOLVESTATBLOCKS_EXIT1, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 		}

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDRESOLVESTATBLOCKS_EXIT2, this, (TInt) ESchedContinue );

 	return ESchedContinue;

 	}

 DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedGroundDown(DMMCSession* aSessP, TMMCErr aReason)

 /**

  * Aborts all asynchronous activities of session aSessP with

  * iExitCode = aReason. This function conserns itself with asynchronous

  * activities only; session static state (eg Critical) is not taken into

  * account. Session dynamic state and action flags (i.e. SafeInGaps,

  * DoReSchedule and DoDFC) are cleared.

  * @param aSessP A pointer to the session.

  * @param aReason The reason for aborting.

  * @return EschedContinue if everything's done OK.

  * @return ESchedLoop if the session can not be safely grounded (eg

  * iStackSession) and should therefore be aborted and/or completed by a

  * separate scheduler pass.

  */

 	{

 	OstTraceExt3(TRACE_FLOW, DMMCSTACK_SCHEDGROUNDDOWN_ENTRY, "DMMCStack::SchedGroundDown;aSessionP=%x;aReason=%d;this=%x", (TUint) aSessP, (TInt) aReason, (TUint) this);

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sgdn"));

 	if( (aSessP == iStackSession) || InitStackInProgress() )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDGROUNDDOWN_EXIT1, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 	    }

 	if( aSessP->iState & KMMCSessStateInProgress )

 		{

 		SchedDoAbort( aSessP );

 		//coverity[check_return]

 		//return value is not saved or checked because there is no further uses.

 		aSessP->iMachine.SetExitCode( aReason );

 		aSessP->iState &= ~(KMMCSessStateSafeInGaps | KMMCSessStateDoReSchedule |

 							KMMCSessStateDoDFC);

 		}

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDGROUNDDOWN_EXIT2, this, (TInt) ESchedContinue );

 	return ESchedContinue;

 	}

 DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedEnqueStackSession(TMMCSessionTypeEnum aSessID)

 /**

  * Prepare internal session for InitStack and enque it into WorkSet.

  * @return EschedContinue or ESchedLoop

  */

 	{

 	OstTraceExt2(TRACE_FLOW, DMMCSTACK_SCHEDENQUESTACKSESSION_ENTRY ,"DMMCStack::SchedEnqueStackSession;aSessID=%d;this=%x", (TInt) aSessID, (TUint) this);

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sess"));

 		if( iStackSession->IsEngaged() )

 			{

 			MarkComplete( iStackSession, KMMCErrAbort );

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDENQUESTACKSESSION_EXIT1, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 			}

 		iStackSession->SetupCIMControl( aSessID );

 		iWorkSet.Add( iStackSession );

 		iStackSession->iState |= KMMCSessStateEngaged;

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDENQUESTACKSESSION_EXIT2, this, (TInt) ESchedContinue );

 		return ESchedContinue;

 	}

 void DMMCStack::SchedGrabEntries()

 /**

  * Merges Entry queue into Ready queue. Invoked at the scheduler entry and

  * after the completion pass

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDGRABENTRIES_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sge"));

 	iAttention = EFalse;		// Strictly in this order

 	if( !iEntryQueue.IsEmpty() )

 		{

 		DISABLEPREEMPTION

 		iReadyQueue.Add( iEntryQueue );

 		RESTOREPREEMPTION

 		}

 	OstTraceFunctionExit1( DMMCSTACK_SCHEDGRABENTRIES_EXIT, this );

 	}

 void DMMCStack::SchedDisengage()

 /**

  * This function is called by AbortPass() and CompletionPass() to remove the session

  * at WorkSet Point, to abort its asynchronous activities (if any) and

  * clear up the dependent resources

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDDISENGAGE_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sd"));

 	DMMCSession* sessP = iWorkSet.Remove();

 	SchedDoAbort( sessP );

 	if( sessP == iSessionP )

 		iSessionP = NULL;

 	if( sessP->iCardP != NULL && sessP->iCardP->iUsingSessionP == sessP )

 		sessP->iCardP->iUsingSessionP = NULL;

 	// iAutoUnlockSession may attach to more than once card, so need to iterate 

 	// through all cards and clear their session pointers if they match sessP

 	if (sessP == &iAutoUnlockSession)

 		{

 		for (TUint i = 0; i < iMaxCardsInStack; i++)

 			{

 			TMMCard& cd = *(iCardArray->CardP(i));

 			if (cd.iUsingSessionP == sessP)

 				cd.iUsingSessionP = NULL;

 			}

 		}

 	if( sessP->iState & KMMCSessStateASSPEngaged )

 		ASSPDisengage();

 	sessP->iState = 0;

 	OstTraceFunctionExit1( DMMCSTACK_SCHEDDISENGAGE_EXIT, this );

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedAbortPass()

 /**

  * DMMCStack Scheduler private inline functions. These functions were separated as inline functions

  * only for the sake of Scheduler() clarity.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDABORTPASS_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sap"));

 	iAbortReq = EFalse;

 	SchedGrabEntries();

 	DMMCSession* sessP;

 	iWorkSet.Point();

 	while( (sessP = iWorkSet) != NULL )

 		if( iAbortAll || sessP->iDoAbort )

 			SchedDisengage();

 		else

 			iWorkSet++;

 	iReadyQueue.Point();

 	while( (sessP = iReadyQueue) != NULL )

 		if( iAbortAll || sessP->iDoAbort )

 			{

 			iReadyQueue.Remove();

 			sessP->iState = 0;

 			}

 		else

 			iReadyQueue++;

 	if( iAbortReq )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDABORTPASS_EXIT1, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 	    }

 	// Clearing iAbortAll here is a bit dodgy. It wouldn't work if somebody interrupted us

 	// at this point, enqued a session and then immediately called Reset() - that session

 	// would not be discarded. However, the correct solution (enque Reset() requests

 	// and process them in the Scheduler main loop) seems to be too expensive just to avoid

 	// this particular effect.

 	iAbortAll = EFalse;

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDABORTPASS_EXIT2, this, (TInt) ESchedContinue  );

 	return ESchedContinue;

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedCompletionPass()

 /**

  * This function calls back all the sessions waiting to be completed

  * Returns either Continue or Loop.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDCOMPLETIONPASS_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:scp"));

 	iCompReq = EFalse;

 	DMMCSession* sessP;

 	if( iCompleteAllExitCode )

 		{

 		SchedGrabEntries();

 		iWorkSet.Add( iReadyQueue );

 		}

 	iWorkSet.Point();

 	while( (sessP = iWorkSet) != NULL )

 		if( iCompleteAllExitCode || sessP->iDoComplete )

 			{

 			if( (EffectiveModes(sessP->iConfig) & KMMCModeCompleteInStackDFC) != 0 &&

 				 SchedGetOnDFC() )

 				{

 				// DFC has been queued so return back to main loop.  Next time

 				// SchedGetOnDfc() will return EFalse, and the callback will be called.

 				iCompReq = ETrue;

 				OstTraceFunctionExitExt( DMMCSTACK_SCHEDCOMPLETIONPASS_EXIT1, this, (TInt) ESchedLoop );

 				return ESchedLoop;

 				}

 			SchedDisengage();					// calls iWorkSet.Remove

 			sessP->iMMCExitCode |= iCompleteAllExitCode;

 			// Update the controller store if a password operation was in progress.

 			TBool doCallback = ETrue;

 			if (sessP->iSessionID == ECIMLockUnlock)

 				{

 				iSocket->PasswordControlEnd(sessP, sessP->EpocErrorCode());

 				if(sessP->EpocErrorCode() == KErrNone)

 					{

 					sessP->SetupCIMInitStackAfterUnlock();

 					if(sessP->Engage() == KErrNone)

 						{

 						doCallback = EFalse;

 						}

 					}

 				}

 			if(sessP->iSessionID == ECIMInitStackAfterUnlock)

 				{

 				// After unlocking the stack, cards may have switched into HS mode

 				// (HS switch commands are only valid when the card is unlocked).

 				//

 				// Therefore, we need to re-negotiate the maximum bus clock again.

 				//

 				// The PSL will use this to set the master config (limiting the clock if

 				// appropriate).

 				//

 				// Note that the clock may change when a specific card is selected.

 				//

 				TUint maxClk;

 				iCardArray->UpdateAcquisitions(&maxClk);

 				SetBusConfigDefaults( iMasterConfig.iBusConfig, maxClk );

 				DoSetClock(maxClk);

 				}

 			if(doCallback)

 				{

 				// call media driver completion routine or StackSessionCBST().

 				sessP->iCallBack.CallBack();

 				}

 			}

 		else

 			iWorkSet++;

 	if( iCompReq )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDCOMPLETIONPASS_EXIT2, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 	    }

 	iCompleteAllExitCode = 0;

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDCOMPLETIONPASS_EXIT3, this, ( TInt) ESchedContinue );

 	return ESchedContinue;

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedInitStack()

 /**

  * "Immediate" InitStack initiator. Returns either Continue or Loop.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDINITSTACK_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sis"));

 	if( SchedGetOnDFC() )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDINITSTACK_EXIT1, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 	    }

 	if( iSessionP != NULL && (iStackState & KMMCStackStateJobChooser) == 0 )

 		{

 		if( (iSessionP->iState & KMMCSessStateInProgress) )

 			{

 			if( SchedGroundDown(iSessionP, KMMCErrPowerDown) )

 				{

 				MarkComplete( iSessionP, KMMCErrPowerDown );

 				OstTraceFunctionExitExt( DMMCSTACK_SCHEDINITSTACK_EXIT2, this, (TInt) ESchedLoop );

 				return ESchedLoop;

 				}

 			}

 		else

 			iSessionP->iMachine.Reset();

 		}

 	// NB if the current session was InitStack InProgress, JobChooser can not be active;

 	// so we are not going to continue another InitStack as if nothing happened.

 	iStackState &= ~(KMMCStackStateInitInProgress|KMMCStackStateInitPending);

 	// If there is no current session (e.g. called from PowerUpStack()) or the current

 	// session isn't specifically ECIMInitStack (which it rarely will be) then we have to use

 	// the stack session to perform the stack init.

 	if( iSessionP == NULL || iSessionP->iSessionID != ECIMInitStack )

 		{

 		if( SchedEnqueStackSession(ECIMInitStack) )

 		    {

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDINITSTACK_EXIT3, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 		    }

 		SchedSetContext( iStackSession );	// make the internal session to be current job

 		}

 	// Neither client nor internal session could be blocked here, not even on "BrokenLock"

 	__ASSERT_ALWAYS( (iSessionP->iBlockOn)==0,

 	DMMCSocket::Panic(DMMCSocket::EMMCInitStackBlocked) );

 	iStackState |= KMMCStackStateInitInProgress;

 	// nothing can stop this session now; it's safe to clear iInitialise here.

 	iInitialise = EFalse;

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDINITSTACK_EXIT4, this, (TInt) ESchedContinue );

 	return ESchedContinue;

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedSleepStack()

 /**

  * "Immediate" Stack sleep mode. Returns either Continue or Loop.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDSLEEPSTACK_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:SchdSlp!"));

 	// Make sure Stack DFC is Running!

 	if( SchedGetOnDFC() )

 		{

 		__KTRACE_OPT(KPBUS1, Kern::Printf("mst:SchdSlp - DFC not running"));

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSLEEPSTACK_EXIT1, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 		}

 	if( iSessionP != NULL && (iStackState & KMMCStackStateJobChooser) == 0 )

 		{

 		if( (iSessionP->iState & KMMCSessStateInProgress) )

 			{

 			// A session has been queued before sleep, 

 			// cancel sleep and loop for next session

 			iSleep = EFalse;

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDSLEEPSTACK_EXIT2, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 			}

 		}

 	// Use the stack session to perform the stack sleep.

 	if( SchedEnqueStackSession(ECIMSleep) )

 		{

 		__KTRACE_OPT(KPBUS1,Kern::Printf("SchdSlp: already Enqued"));

 		// Stack already busy cancel sleep

 		iSleep = EFalse;

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSLEEPSTACK_EXIT3, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 		}

 	SchedSetContext( iStackSession );	// make the internal session to be current job

 	// Sleep has now been queued

 	iSleep = EFalse;

 	iStackState |= KMMCStackStateSleepinProgress;

 	__KTRACE_OPT(KPBUS1, Kern::Printf("<mst:SchdSlp"));

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDSLEEPSTACK_EXIT4, this, (TInt) ESchedLoop );

 	return ESchedLoop;

 	}

 inline TBool DMMCStack::SchedPreemptable()

 /**

  * Checks if the current session can be preempted

  */

 	{	// strictly in the following order

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDPREEMPTABLE_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:spe"));

 	if( (iStackState & KMMCStackStateJobChooser) ||

 		(iSessionP->iState & KMMCSessStateDoReSchedule) )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT1, this, (TUint) ETrue );

 		return ETrue;

 	    }

 	if( (iSessionP->iBlockOn & KMMCBlockOnASSPFunction) )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT2, this, (TUint) EFalse );

 		return EFalse;

 	    }

 	TBool preemptDC = EFalse;	

 	if (iSessionP->iBlockOn & KMMCBlockOnYielding)

 		{

 		// Added to support yielding the stack for a specific command.

 		preemptDC = ETrue;		

 		}

 	else if( (iSessionP->iBlockOn & KMMCBlockOnDataTransfer) )

 		{

 		// Added for SDIO Read/Wait and SDC support.  This condition

 		// is set at the variant, and determines whether commands may be

 		// issued during the data transfer period.

 		if(!(iSessionP->iState & KMMCSessStateAllowDirectCommands))

 		    {

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT3, this, (TUint) EFalse );

 			return EFalse;

 		    }

 		// We must consider the remaining blocking conditions

 		// before being sure that we can enable pre-emtion of this session

 		preemptDC = ETrue;

 		}

 	if( (iSessionP->iBlockOn & (KMMCBlockOnCardInUse | KMMCBlockOnNoRun)) )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT4, this, (TUint) ETrue );

 		return ETrue;

 	    }

 	if( (iConfig.iModes & KMMCModeEnablePreemption) == 0 )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT5, this, (TUint) EFalse );

 		return EFalse;

 	    }

 	if( (iSessionP->iBlockOn & KMMCBlockOnGapTimersMask) &&

 		(iConfig.iModes & KMMCModePreemptInGaps) &&

 		(iSessionP->iState & KMMCSessStateSafeInGaps) )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT6, this, (TUint) ETrue );

 		return ETrue;

 	    }

 	if( iSessionP->iBlockOn & KMMCBlockOnInterrupt )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT7, this, (TUint) ETrue );

 		return ETrue;

 	    }

 	if(preemptDC)

 	    {

 		OstTraceFunctionExitExt( DDMMCSTACK_SCHEDPREEMPTABLE_EXIT8, this, (TUint) ETrue );

 		return ETrue;

 	    }

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDPREEMPTABLE_EXIT9, this, (TUint) EFalse );

 	return EFalse;

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedSession()

 /**

  * Current context analyser. Returns Exit, Loop or ChooseJob.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDSESSION_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:ss"));

 	// If no current session selected then we need to choose one

 	if (iSessionP == NULL)

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT1, this, (TInt) ESchedChooseJob );

 		return ESchedChooseJob;

 	    }

 	// Check any static blocking conditions on the current session and remove if possible

 	if (SchedResolveStatBlocks(iSessionP)==ESchedLoop)

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT2, this, (TInt) ESchedLoop );

 		return ESchedLoop;

 	    }

 	// If current session is still blocked, see if we could pre-empt the session

 	if (iSessionP->iBlockOn)

 		{

 		if( SchedPreemptable() )

 		    {

 		    OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT3, this, (TInt) ESchedChooseJob );

 			return ESchedChooseJob;

 		    }

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT4, this, (TInt) ESchedExit );

 		return ESchedExit;	// No preemption possible

 		}

 	// If the current session has been marked to be 'un-scheduled' then we

 	// need to choose another session if ones available

 	if ( (iSessionP->iState & KMMCSessStateDoReSchedule) )

 	    {

 		OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT5, this, (TInt) ESchedChooseJob );

 		return ESchedChooseJob;

 	    }

 	// Check if this session requires to be run in DFC context - loop if necessary

 	if ( (iSessionP->iState & KMMCSessStateDoDFC) )

 		{

 		iSessionP->iState &= ~KMMCSessStateDoDFC;

 		if( SchedGetOnDFC()==ESchedLoop )

 		    {

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT6, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 		    }

 		}

 	// Now we actually execute the current session

 	if( iLockingSessionP != NULL )

 		{

 		if( (iStackState & KMMCStackStateLocked) )

 			{

 			if( iSessionP != iLockingSessionP )

 				{

 				iLockingSessionP->iBrokenLock = ETrue;

 				iLockingSessionP = NULL;

 				DeselectsToIssue(KMMCIdleCommandsAtRestart); // use it for the number of deselects as well

 				}

 			}

 		else

 			if( iSessionP == iLockingSessionP )

 				iStackState |= KMMCStackStateLocked;

 		}

 	if( iSessionP->iInitContext != iInitContext )

 		{

 		// If the current session's init_stack pass number is set but isn't the same as the current

 		// pass number, it indicates this session is being resumed having tried to recover from

 		// a bus inconsitency by re-initialising the stack. Set the exit code to a special

 		// value so this session can un-wind from where the initial error occured, back to the start.

 		if( iSessionP->iInitContext != 0 )

 			//coverity[check_return]

 			//return value is not saved or checked because there is no further uses.

 			iSessionP->iMachine.SetExitCode(KMMCErrInitContext | iSessionP->iMachine.ExitCode());

 		iSessionP->iInitContext = iInitContext;

 		}

 	iStackState &= ~KMMCStackStateJobChooser;

 	iSessionP->iState &= ~KMMCSessStateSafeInGaps;

 	// Execute the session state machine until it completes, is blocked or is aborted.

 	TMMCErr exitCode = iSessionP->iMachine.Dispatch();

 	iStackState &= ~KMMCStackStateReScheduled;

 	if( exitCode )

 		MarkComplete( iSessionP, (exitCode & ~KMMCErrBypass) );

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDSESSION_EXIT7, this, (TInt) ESchedLoop );

 	return ESchedLoop;

 	}

 TBool DMMCStack::SchedYielding(DMMCSession* aSessP)

 /**

  * Check whether the scheduler should yield to another command

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_SCHEDYIELDING_ENTRY, this );

 	// Test whether a full loop through the sessions has occurred during a yield

 	if ((aSessP->iBlockOn & KMMCBlockOnYielding) && (iStackState & KMMCStackStateYielding))

 		{

 		// We've looped, now stop yielding

 		aSessP->iBlockOn &= ~KMMCBlockOnYielding;

 		iStackState &= ~KMMCStackStateYielding;

 		}

 	TBool ret = (iStackState & KMMCStackStateYielding) != 0;

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDYIELDING_EXIT, this, ret );

 	return ret;

 	}

 TBool DMMCStack::SchedAllowDirectCommands(DMMCSession* aSessP)

 /**

  * Check whether direct only commands can be run.

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_SCHEDALLOWDIRECTCOMMANDS_ENTRY, this );

 	TBool allowDirectCommands = EFalse;

 	// Test the remaining sessions to see if they have a DMA data transfer blockage which allow direct commands only

 	DMMCSession* testSessP = aSessP;

 	do

 		{

 		if ((testSessP->iBlockOn & KMMCBlockOnDataTransfer) && (testSessP->iState & KMMCSessStateAllowDirectCommands))

 			allowDirectCommands = ETrue;

 		testSessP = testSessP->iLinkP;

 		}			

 	while((aSessP != testSessP) && (testSessP != NULL));

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDALLOWDIRECTCOMMANDS_EXIT, this, allowDirectCommands );

 	return allowDirectCommands;

 	}

 inline DMMCStack::TMMCStackSchedStateEnum DMMCStack::SchedChooseJob()

 /**

  * Find an unblocked job to run. Returns Exit or Loop.

  */

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_SCHEDCHOOSEJOB_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:scj"));

 	iStackState |= KMMCStackStateJobChooser;

 	SchedGrabEntries();

 	DMMCSession* sessP = NULL;

 	if( iLockingSessionP != NULL )		// if stack is already locked we accept only locking session

 		{

 		if( iWorkSet.IsEmpty() && iReadyQueue.Point(iLockingSessionP) )

 			sessP = iReadyQueue.Remove();

 		}

 	else								// otherwise we might add a fresh session from reserve

 		{

 		iStackState &= ~KMMCStackStateLocked;

 		if( iWorkSet.Size() < KMMCMaxJobsInStackWorkSet &&		// if work set is not too big

 			!iReadyQueue.IsEmpty() &&							// and there are ready sessions

 			(iStackState & KMMCStackStateWaitingToLock) == 0 )	// and nobody waits to lock us

 			{

 			iReadyQueue.Point();								// at marker to preserve FIFO

 			sessP = iReadyQueue.Remove();

 			}

 		}

 	if( sessP != NULL )

 		{

 		iWorkSet.Add( sessP );

 		if( sessP->iSessionID == ECIMLockStack )

 			{

 			sessP->SynchBlock( KMMCBlockOnWaitToLock | KMMCBlockOnNoRun );

 			sessP->iBrokenLock = EFalse;

 			iStackState |= KMMCStackStateWaitingToLock;

 			}

 		}

 	if( iSessionP  != NULL )

 		iWorkSet.AdvanceMarker();		// move current session to the end of the queue

 	iWorkSet.Point();

 	while( (sessP = iWorkSet) != NULL )

 		{

 		// first, remove all static blocking conditions

 		if( SchedResolveStatBlocks(sessP) )

 		    {

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDCHOOSEJOB_EXIT1, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 		    }

 		TBool scheduleSession = ETrue;

 		// Test whether we are yielding 

 		if (SchedYielding(sessP) && (sessP->Command().iSpec.iCommandType != iYieldCommandType))

 			scheduleSession = EFalse;

 		// Test whether this session is blocked

 		else if (sessP->iBlockOn)

 			scheduleSession = EFalse;

 		// Test whether we can only handle direct commands

 		else if (SchedAllowDirectCommands(sessP) && (sessP->Command().iSpec.iCommandType != ECmdTypeADC))

 			scheduleSession = EFalse;

 		if (scheduleSession)

 			{

 			iWorkSet.SetMarker();

 			SchedSetContext( sessP );

 			OstTraceFunctionExitExt( DMMCSTACK_SCHEDCHOOSEJOB_EXIT2, this, (TInt) ESchedLoop );

 			return ESchedLoop;

 			}

 		iWorkSet++;

 		}

 	OstTraceFunctionExitExt( DMMCSTACK_SCHEDCHOOSEJOB_EXIT3, this, (TInt) ESchedExit );

 	return ESchedExit;		

 	}

 void DMMCStack::StackDFC(TAny* aStackP)

 /**

  * This DFC is used to startup Stack Scheduler from the background.

  */

 	{

 	OstTraceFunctionEntry0( DMMCSTACK_STACKDFC_ENTRY );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sdf"));

 	DMMCStack* const stackP = static_cast<DMMCStack*>(aStackP);

 	stackP->Scheduler( stackP->iDFCRunning );

 	OstTraceFunctionExit0( DMMCSTACK_STACKDFC_EXIT );

 	}

 void DMMCStack::Scheduler(volatile TBool& aFlag)

 /**

  * This is the main function which controls, monitors and synchronises session execution.

  * It's divided into the entry function Scheduler() and the scheduling mechanism itself,

  * DoSchedule()

  */

 	{

 	OstTraceFunctionEntry0( DMMCSTACK_SCHEDULER_ENTRY );

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:sch"));

 	DISABLEPREEMPTION

 	aFlag = ETrue;

 	if( iStackState & KMMCStackStateRunning )

 		{

 		RESTOREPREEMPTION

 		return;

 		}

 	iStackState |= KMMCStackStateRunning;

 	RESTOREPREEMPTION

 	DoSchedule();

 	OstTraceFunctionExit0( DMMCSTACK_SCHEDULER_EXIT );

 	}

 void DMMCStack::DoSchedule()

 	{

 	OstTraceFunctionEntry1( DMMCSTACK_DOSCHEDULE_ENTRY, this );

 	__KTRACE_OPT(KPBUS1,Kern::Printf(">mst:dos"));

 	for(;;)

 		{

 		for(;;)

 			{

 			if( iAbortReq && SchedAbortPass() )

 				continue;

 			if( iDFCRunning )

 				iStackState &= ~KMMCStackStateWaitingDFC;

 			else

 				if( iStackState & KMMCStackStateWaitingDFC )

 					break;

 			if( iCompReq && SchedCompletionPass() )

 				continue;

 			if( iInitialise && SchedInitStack() )

 				continue;

 			if( iSleep && SchedSleepStack() )

 				continue;

 			iAttention = EFalse;

 			DMMCStack::TMMCStackSchedStateEnum toDo = SchedSession();

 			if( toDo == ESchedLoop )

 				continue;

 			if( toDo == ESchedExit )

 				break;

 			if( SchedChooseJob() == ESchedExit )

 				break;

 			}

 		DISABLEPREEMPTION

 		if( !iAbortReq &&

 			((iStackState & KMMCStackStateWaitingDFC) ||

 			 (iCompReq | iInitialise | iAttention)==0) ||

 			 ((iSessionP) && (iSessionP->iState & KMMCSessStateAllowDirectCommands)))

 			{

 			// Clear DFC flag here in case somebody was running scheduler in the background

 			// when DFC turned up. This should never really happen, but with EPOC who knows

 			iStackState &= ~KMMCStackStateRunning;

 			iDFCRunning = EFalse;

 			RESTOREPREEMPTION

 			__KTRACE_OPT(KPBUS1,Kern::Printf("<mst:dos"));

 			OstTraceFunctionExit1( DMMCSTACK_DOSCHEDULE_EXIT1, this );

 			return;

 			}

 		RESTOREPREEMPTION

 		}

 	}

 //

 // DMMCStack:: --- Session service ---

 //

 void DMMCStack::Add(DMMCSession* aSessP)

 /**

  * Adds session aSessP to the EntryQueue (asynchronous function)

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_ADD_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf(">MMC:Add %d",TUint(aSessP->iSessionID)));

 	DISABLEPREEMPTION

 	iEntryQueue.Add( aSessP );

 	aSessP->iState |= KMMCSessStateEngaged;

 	RESTOREPREEMPTION

 	Scheduler( iAttention );

 	OstTraceFunctionExit1( DMMCSTACK_ADD_EXIT, this );

 	}

 void DMMCStack::Abort(DMMCSession* aSessP)

 /**

  * Aborts a session

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_ABORT_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:abt"));

 	if( !aSessP->IsEngaged() )

 	    {

 		OstTraceFunctionExit1( DMMCSTACK_ABORT_EXIT1, this );

 		return;

 	    }

 	aSessP->iDoAbort = ETrue;

 	aSessP->iMachine.Abort();

 	Scheduler( iAbortReq );

 	OstTraceFunctionExit1( DMMCSTACK_ABORT_EXIT2, this );

 	}

 void DMMCStack::Stop(DMMCSession* aSessP)

 /**

  * Signals session to stop

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_STOP1_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:stp"));

 	if( !aSessP->IsEngaged() )

 	    {

 		OstTraceFunctionExit1( DMMCSTACK_STOP1_EXIT1, this );

 		return;

 	    }

 	aSessP->iDoStop = ETrue;

 	OstTraceFunctionExit1( DMMCSTACK_STOP1_EXIT2, this );

 	}

 EXPORT_C void DMMCStack::Block(DMMCSession* aSessP, TUint32 aFlag)

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_BLOCK_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:blk"));

 	if( !aSessP->IsEngaged() )

 	    {

 		OstTraceFunctionExit1( DMMCSTACK_BLOCK_EXIT1, this );

 		return;

 	    }

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:blk:[aFlag=%08x, iBlockOn=%08x]", aFlag, aSessP->iBlockOn));

 	OstTraceExt2( TRACE_INTERNALS, DMMCSTACK_BLOCK, "aFlag=0x%08x; iBlockOn=0x%08x", aFlag, aSessP->iBlockOn );

 	(void)__e32_atomic_ior_ord32(&aSessP->iBlockOn, aFlag);

 	OstTraceFunctionExit1( DMMCSTACK_BLOCK_EXIT2, this );

 	}

 EXPORT_C void DMMCStack::UnBlock(DMMCSession* aSessP, TUint32 aFlag, TMMCErr anExitCode)

 /**

  * aFlag is a bitset of KMMCBlockOnXXX events that have occured.  If the stack's

  * session is waiting on all of these events, then it is scheduled.

  */

 	{

 	OstTraceExt4(TRACE_FLOW, DMMCSTACK_UNBLOCK_ENTRY , "DMMCStack::UnBlock;aSessP=%x;aFlag=%x;anExitCode=%d;this=%x", (TUint) aSessP, (TUint) aFlag, (TInt) anExitCode, (TUint) this);

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:ubl"));

 	if (aSessP != NULL)

 		{

 		__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:ubl:[aFlag=%08x, iBlockOn=%08x", aFlag, aSessP->iBlockOn));

 		OstTraceExt2( TRACE_INTERNALS, DMMCSTACK_UNBLOCK, "aFlag=0x%08x; iBlockOn=0x%08x", aFlag, aSessP->iBlockOn );

 		if( (aSessP->iBlockOn & aFlag) == 0 )

 		    {

 			OstTraceFunctionExit1( DMMCSTACK_UNBLOCK_EXIT1, this );

 			return;

 		    }

 		// Must be either in a DFC or have the KMMCSessStateDoDFC flag set

 		__ASSERT_DEBUG( 

 			(aSessP->iState & KMMCSessStateDoDFC) != 0 || 

 			NKern::CurrentContext() != NKern::EInterrupt,

 			DMMCSocket::Panic(DMMCSocket::EMMCUnblockingInWrongContext));

 		(void)__e32_atomic_and_ord32(&aSessP->iBlockOn, ~aFlag);

 		aSessP->iMachine.SetExitCode( anExitCode );

 		if( aSessP->iBlockOn == 0 )

 			Scheduler( iAttention );

 		}

 	OstTraceFunctionExit1( DMMCSTACK_UNBLOCK_EXIT2, this );

 	}

 void DMMCStack::UnlockStack(DMMCSession* aSessP)

 /**

  * Removes stack lock. Asynchronous function.

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_UNLOCKSTACK_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:ust"));

 	aSessP->iBrokenLock = EFalse;

 	if( aSessP == iLockingSessionP )

 		{

 		iLockingSessionP = NULL;

 		Scheduler( iAttention );

 		}

 	OstTraceFunctionExit1( DMMCSTACK_UNLOCKSTACK_EXIT1, this );

 	}

 EXPORT_C TInt DMMCStack::Stop(TMMCard* aCardP)

 /**

  * Completes all sessions operating with a specified card with KMMCErrAbort.

  * Returns either KErrNone or KErrServerBusy.

  */

 	{

 	OstTraceFunctionEntryExt( DMMCSTACK_STOP2_ENTRY, this );

 	ASSERT_NOT_ISR_CONTEXT

 	__KTRACE_OPT(KPBUS1,Kern::Printf("=mst:stp"));

 	DISABLEPREEMPTION

 	if( iStackState & KMMCStackStateRunning )

 		{

 		RESTOREPREEMPTION

 		return KErrServerBusy;	// can not operate in foreground

 		}

 	iStackState |= KMMCStackStateRunning;

 	RESTOREPREEMPTION

 	DMMCSession* sessP;

 	SchedGrabEntries();

 	iWorkSet.Point();

 	while( (sessP = iWorkSet++) != NULL )

 		if( sessP->iCardP == aCardP )

 			MarkComplete( sessP, KMMCErrAbort );

 	iReadyQueue.Point();

 	while( (sessP = iReadyQueue) != NULL )

 		if( sessP->iCardP == aCardP )

 			{

 			MarkComplete( sessP, KMMCErrAbort );

 			iReadyQueue.Remove();

 			iWorkSet.Add( sessP );

 			}

 		else

 			iReadyQueue++;