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

//

#include <drivers/sdcard.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "../../../../include/drivers/locmedia_ost.h"

#ifdef __VC32__

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

#endif

#include "sdcardTraces.h"

#endif

// ======== TSDCard ========

TSDCard::TSDCard()

:	iProtectedAreaSize(0), iPARootDirEnd(KPARootDirEndUnknown), iClientCountSD(0)

	{

	}

TInt64 TSDCard::DeviceSize64() const

//

// returns the SD device size

//

	{

	OstTraceFunctionEntry1( TSDCARD_DEVICESIZE64_ENTRY, this );

	if(iFlags & KSDCardIsSDCard)

		{	

		return (IsHighCapacity()) ? 512 * 1024 * (TInt64)(1 + CSD().CSDField(69, 48)) : TMMCard::DeviceSize64();

		}

	return(TMMCard::DeviceSize64());

	}

TUint32 TSDCard::PreferredWriteGroupLength() const

//

// return SD erase sector size, (SECTOR_SIZE + 1) * 2 ** WRITE_BLK_LEN

//

	{

	OstTraceFunctionEntry1( TSDCARD_PREFERREDWRITEGROUPLENGTH_ENTRY, this );

	if(iFlags & KSDCardIsSDCard)

		{	

		TSDCSD sdcsd(CSD());

		return (sdcsd.SDSectorSize() + 1) * (1 << sdcsd.WriteBlLen());

		}

	return(TMMCard::PreferredWriteGroupLength());

	}

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

	{

	return KErrNotSupported;

	}

TUint32 TSDCard::MinEraseSectorSize() const

	{

	if(iFlags&KSDCardIsSDCard)

		{	

		TSDCSD sdcsd(CSD());

		if (sdcsd.SDEraseBlkEn())

			return sdcsd.WriteBlockLength();		// raised logarithm

		else

			return (sdcsd.SDSectorSize() + 1) * sdcsd.WriteBlockLength();

		}

	return TMMCard::MinEraseSectorSize();

	}

const TUint32 KEraseSectorSizeShift = 8;	// KEraseSectorSizeShift determines the multiple of the sector size 

											// that can be erased in one operation

TUint32 TSDCard::EraseSectorSize() const

	{

	if(iFlags&KSDCardIsSDCard)

		{	

		TSDCSD sdcsd(CSD());

		return ((sdcsd.SDSectorSize() + 1) * sdcsd.WriteBlockLength()) << KEraseSectorSizeShift;

		}

	return TMMCard::EraseSectorSize();

	}

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

const TInt KDefaultBlockLenInBytes = 1 << KDefaultBlockLen;		// 2^9 = 512 bytes

const TInt KTwoGbyteSDBlockLen	   = 10;						// 2^10 = 1024 bytes

const TInt KFourGbyteSDBlockLen	   = 11;						// 2^11 = 2048 bytes

TInt TSDCard::GetEraseInfo(TMMCEraseInfo& aEraseInfo) const

//

// Return info. on erase services for this card

//

	{

	OstTraceFunctionEntry1( TSDCARD_GETERASEINFO_ENTRY, this );

	// SD Controllers support MMC cards too. Check if we are really dealing with an SD card

	if(!(iFlags&KSDCardIsSDCard))

		return(TMMCard::GetEraseInfo(aEraseInfo));

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

		{

		// This card supports erase cmds. However, SD cards don't support Erase Group commands (i.e. CMD35, CMD36).

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

		aEraseInfo.iEraseFlags=KMMCEraseClassCmdsSupported; 

		// Return the preferred size to be used as the unit for erase operations.

		TSDCSD sdcsd(CSD());

		TUint32 prefSize=((sdcsd.SDSectorSize() + 1) * sdcsd.WriteBlockLength());

		prefSize<<=KEraseSectorSizeShift;		// Use multiples of the sector size for each erase operation

		aEraseInfo.iPreferredEraseUnitSize=prefSize;

		// Return the smallest size that can be used as the unit for erase operations

		if (sdcsd.SDEraseBlkEn())

			{

			aEraseInfo.iMinEraseSectorSize = KDefaultBlockLenInBytes;

			}

		else

			{

			aEraseInfo.iMinEraseSectorSize=(sdcsd.SDSectorSize() + 1) * sdcsd.WriteBlockLength();

			}

		}

	else		

		aEraseInfo.iEraseFlags=0;

	OstTraceFunctionExitExt( TSDCARD_GETERASEINFO_EXIT, this, KErrNone );

	return KErrNone;	

	}

TInt TSDCard::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( TSDCARD_MAXREADBLLEN_ENTRY, this );

	if (IsSDCard())

		{

		TInt blkLenLog2 = CSD().ReadBlLen();

		if (blkLenLog2 == KTwoGbyteSDBlockLen || blkLenLog2 == KFourGbyteSDBlockLen)

			{

			// The SD card spec. makes a special case for 2GByte cards,

			// ...and some manufacturers apply the same method to support 4G cards

			__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mrbl > 2GB SD"));

			OstTrace0( TRACE_INTERNALS, TSDCARD_MAXREADBLLEN, "SD Card > 2GB" );

			blkLenLog2 = KDefaultBlockLen;

			}

		OstTraceFunctionExitExt( TSDCARD_MAXREADBLLEN_EXIT, this, blkLenLog2 );

		return blkLenLog2;

		}

	else		// MMC card

		{

		TInt ret = TMMCard::MaxReadBlLen();

		OstTraceFunctionExitExt( DUP1_TSDCARD_MAXREADBLLEN_EXIT, this, ret );

		return ret;

		}

	}

TInt TSDCard::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( TSDCARD_MAXWRITEBLLEN_ENTRY, this );

	if (IsSDCard())

		{

		TInt blkLenLog2 = CSD().WriteBlLen();

		if (blkLenLog2 == KTwoGbyteSDBlockLen || blkLenLog2 == KFourGbyteSDBlockLen)

			{

			// The SD card spec. makes a special case for 2GByte cards,

			// ...and some manufacturers apply the same method to support 4G cards

			__KTRACE_OPT(KPBUS1, Kern::Printf("=mmc:mwbl > 2GB SD"));

			OstTrace0( TRACE_INTERNALS, TSDCARD_MAXWRITEBLLEN, "SD Card > 2GB" );

			blkLenLog2 = KDefaultBlockLen;

			}

		OstTraceFunctionExitExt( TSDCARD_MAXWRITEBLLEN_EXIT, this, blkLenLog2 );

		return blkLenLog2;

		}

	else		// MMC card

		{

		TInt ret = TMMCard::MaxWriteBlLen();

		OstTraceFunctionExitExt( DUP1_TSDCARD_MAXWRITEBLLEN_EXIT, this, ret );

		return ret;

		}

	}

TUint TSDCard::MaxTranSpeedInKilohertz() const

/**

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

 * @return Speed, in Kilohertz

 */

	{

	OstTraceFunctionEntry1( TSDCARD_MAXTRANSPEEDINKILOHERTZ_ENTRY, this );

	TUint maxClk = TMMCard::MaxTranSpeedInKilohertz();

	if (IsSDCard())

		{

		__KTRACE_OPT(KPBUS1, Kern::Printf("\t >TSDCard(%d): MaxTranSpeedInKilohertz: %d",(iIndex-1),maxClk));

#ifdef _DEBUG

		//MaxClk for SD should only be either 25000KHz or 50000KHz

		if ( (maxClk != KSDDTClk25MHz) && (maxClk != KSDDTClk50MHz) )

			{

			__KTRACE_OPT(KPBUS1, Kern::Printf("\t >DSDStack: Non-Compliant DT Clock"));

			OstTrace0( TRACE_INTERNALS, TSDCARD_MAXTRANSPEEDINKILOHERTZ, "Non-Compliant DT Clock" );			

			}

#endif

		if (maxClk > KSDDTClk50MHz)

			{

			//Clock rate exceeds SD possible max clock rate

			__KTRACE_OPT(KPBUS1, Kern::Printf("\t >DSDStack: Tuning DT Clock down to 50MHz"));

			OstTrace0( TRACE_INTERNALS, TSDCARD_MAXTRANSPEEDINKILOHERTZ1, "Tuning DT Clock down to 50MHz" );			

			maxClk = KSDDTClk50MHz;

			}

		}

	OstTraceFunctionExitExt( TSDCARD_MAXTRANSPEEDINKILOHERTZ_EXIT, this, maxClk );

	return maxClk;

	}

// ======== TSDCardArray ========

EXPORT_C TInt TSDCardArray::AllocCards()

// 

// allocate TSDCard objects for iCards and iNewCardsArray.  This function

// is called at bootup as part of stack allocation so there is no cleanup

// if it fails.

//

	{

	OstTraceFunctionEntry1( TSDCARDARRAY_ALLOCCARDS_ENTRY, this );

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

		{

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

		// CBase-derived DMMCStack.

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

		    {

			OstTraceFunctionExitExt( TSDCARDARRAY_ALLOCCARDS_EXIT, this, KErrNoMemory );

			return KErrNoMemory;

		    }

		iCards[i]->iUsingSessionP = 0;

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

		    {

			OstTraceFunctionExitExt( DUP1_TSDCARDARRAY_ALLOCCARDS_EXIT, this, KErrNoMemory );

			return KErrNoMemory;

			}

		}

	OstTraceFunctionExitExt( DUP2_TSDCARDARRAY_ALLOCCARDS_EXIT, this, KErrNone );

	return KErrNone;

	}

void TSDCardArray::AddCardSDMode(TUint aCardNumber,const TUint8* aCID,TRCA* aNewRCA)

//

// Add an MMC card straight to the main card array in slot 'aCardNumber'. Save

// the CID value in the slot. Return a RCA for the card.

//

	{

	OstTraceFunctionEntryExt( TSDCARDARRAY_ADDCARDSDMODE_ENTRY, this );

	TRCA rca=0;

	// First, lets check if the same card was here before. If it was, keep the same RCA

	if (Card(aCardNumber).IsPresent() && Card(aCardNumber).iCID==aCID)

		rca=Card(aCardNumber).iRCA;

	else

		{

		// Allocate and new RCA and store the CID in the slot selected

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

		Card(aCardNumber).iCID=aCID;

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

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

		Card(aCardNumber).iRCA=rca;

		iOwningStack->iRCAPool.LockRCA(Card(aCardNumber).iRCA);

		}

	Card(aCardNumber).iIndex=(aCardNumber+1); // Mark card as being present

	*aNewRCA=rca;

	OstTraceFunctionExit1( TSDCARDARRAY_ADDCARDSDMODE_EXIT, this );

	}

TInt TSDCardArray::StoreRCAIfUnique(TUint aCardNumber,TRCA& anRCA)

//

// Check that no other array element has the same RCA value 'anRCA'. If no

// no duplication then store in slot 'aCardNumber'.

//

	{

	OstTraceExt3(TRACE_FLOW, TSDCARDARRAY_STORERCAIFUNIQUE_ENTRY ,"TSDCardArray::StoreRCAIfUnique;aCardNumber=%x;anRCA=%x;this=%x", aCardNumber, (TUint) anRCA, (TUint) this);

	if (anRCA==0)

		{

		OstTraceFunctionExitExt( TSDCARDARRAY_STORERCAIFUNIQUE_EXIT, this, KErrGeneral );

		return KErrGeneral;

		}

	Card(aCardNumber).iRCA=0;

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

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

		{

		if ( Card(i).IsPresent() && Card(i).iRCA==anRCA )

			{

			OstTraceFunctionExitExt( DUP1_TSDCARDARRAY_STORERCAIFUNIQUE_EXIT, this, KErrInUse );

			return KErrInUse;

			}

		}

	Card(aCardNumber).iRCA=anRCA;

	Card(aCardNumber).iIndex=(aCardNumber+1); // Mark card as being present

	OstTraceFunctionExitExt( DUP2_TSDCARDARRAY_STORERCAIFUNIQUE_EXIT, this, KErrNone );

	return KErrNone;

	}

EXPORT_C void TSDCardArray::DeclareCardAsGone(TUint aCardNumber)

//

// reset SD specific fields to initial values and then reset generic MultiMediaCard

//

	{

	OstTraceFunctionEntryExt( TSDCARDARRAY_DECLARECARDASGONE_ENTRY, this );

	Card(aCardNumber).SetBusWidth(1);

	TMMCardArray::DeclareCardAsGone(aCardNumber);

	OstTraceFunctionExit1( TSDCARDARRAY_DECLARECARDASGONE_EXIT, this );

	}

// ======== DSDSession ========

void DSDSession::FillAppCommandDesc(TMMCCommandDesc& aDesc, TSDAppCmd aCmd)

	{

	OstTraceFunctionEntry0( DSDSESSION_FILLAPPCOMMANDDESC_ENTRY );

	aDesc.iCommand = (TMMCCommandEnum) aCmd;

	aDesc.iArgument = 0;						// set stuff bits to zero

	FillAppCommandDesc(aDesc);

	OstTraceFunctionExit0( DSDSESSION_FILLAPPCOMMANDDESC_EXIT );

	}

void DSDSession::FillAppCommandDesc(TMMCCommandDesc& aDesc, TSDAppCmd aCmd, TMMCArgument aArg)

	{

	OstTraceFunctionEntry0( DUP1_DSDSESSION_FILLAPPCOMMANDDESC_ENTRY );

	aDesc.iCommand = (TMMCCommandEnum) aCmd;

	aDesc.iArgument = aArg;

	FillAppCommandDesc(aDesc);

	OstTraceFunctionExit0( DUP1_DSDSESSION_FILLAPPCOMMANDDESC_EXIT );

	}

const TUint32 CCA = KMMCCmdClassApplication;

const TMMCIdxCommandSpec AppCmdSpecTable[] =

	{						//	Class	Type		Dir			MBlk	StopT	Rsp Type		Len

	{ESDACmdSetBusWidth,		{CCA,ECmdTypeACS,	EDirNone,	EFalse, EFalse, ERespTypeR1,	4}}, //ACMD6

	{ESDACmdSDStatus,			{CCA,ECmdTypeADTCS,	EDirRead,	EFalse, EFalse, ERespTypeR1,	4}}, //ACMD13

	{ESDACmdSendNumWrBlocks,	{CCA,ECmdTypeADTCS,	EDirRead,	EFalse, EFalse, ERespTypeR1,	4}}, //ACMD22

	{ESDACmdSetWrBlkEraseCount,	{CCA,ECmdTypeACS,	EDirNone,	EFalse, EFalse, ERespTypeR1,	4}}, //ACMD23

	{ESDACmdSDAppOpCond,		{CCA,ECmdTypeBCR,	EDirNone,	EFalse, EFalse, ERespTypeR3,	4}}, //ACMD41

	{ESDACmdSetClrCardDetect,	{CCA,ECmdTypeAC,	EDirNone,	EFalse, EFalse, ERespTypeR1,	4}}, //ACMD42

	{ESDACmdSendSCR,			{CCA,ECmdTypeADTCS,	EDirRead,	EFalse, EFalse, ERespTypeR1,	4}}  //ACMD51

};

void DSDSession::FillAppCommandDesc(TMMCCommandDesc& aDesc)

	{

	OstTraceFunctionEntry0( DUP2_DSDSESSION_FILLAPPCOMMANDDESC_ENTRY );

	aDesc.iSpec = FindCommandSpec(AppCmdSpecTable, aDesc.iCommand);

	aDesc.iFlags = 0;

	aDesc.iBytesDone = 0;

	OstTraceFunctionExit0( DUP2_DSDSESSION_FILLAPPCOMMANDDESC_EXIT );

	}

const TMMCIdxCommandSpec SdSpecificCmdSpecTable[] =

/**

 * SD Specific Command Table

 *

 *  - Some commands defined in the SD specification overload those defined in the MMC specification.

 *    This table contains the SD specific versions of those commands.

 */

	{

							//   Class				Type			Dir			MBlk	StopT	Rsp Type		Len

	{ESDCmdSendRelativeAddress,	{KMMCCmdClassBasic,	ECmdTypeBCR,	EDirNone,	EFalse,	EFalse,	ERespTypeR6,	4}},	// CMD3 : SEND_RELATIVE_ADDRESS

	{ESDCmdSwitchFunction,		{KMMCCmdClassSwitch,ECmdTypeADTCS,	EDirRead,	EFalse,	EFalse,	ERespTypeR1,	4}},	// CMD6 : SWITCH_FUNCTION

	{ESDCmdSendIfCond,			{KMMCCmdClassBasic,	ECmdTypeBCR,	EDirNone,	EFalse,	EFalse,	ERespTypeR7,	4}}		// CMD8 : SEND_IF_COND

	};

void DSDSession::FillSdSpecificCommandDesc(TMMCCommandDesc& aDesc, TSDSpecificCmd aCmd, TMMCArgument aArg)

	{

	OstTraceFunctionEntry0( DSDSESSION_FILLSDSPECIFICCOMMANDDESC_ENTRY );

	aDesc.iCommand = (TMMCCommandEnum) aCmd;

	aDesc.iArgument = aArg;

	FillSdSpecificCommandDesc(aDesc);

	OstTraceFunctionExit0( DSDSESSION_FILLSDSPECIFICCOMMANDDESC_EXIT );

	}

void DSDSession::FillSdSpecificCommandDesc(TMMCCommandDesc& aDesc, TSDSpecificCmd aCmd)

	{

	OstTraceFunctionEntry0( DUP1_DSDSESSION_FILLSDSPECIFICCOMMANDDESC_ENTRY );

	aDesc.iCommand = (TMMCCommandEnum) aCmd;

	aDesc.iArgument = 0;						// set stuff bits to zero

	FillSdSpecificCommandDesc(aDesc);

	OstTraceFunctionExit0( DUP1_DSDSESSION_FILLSDSPECIFICCOMMANDDESC_EXIT );

	}

void DSDSession::FillSdSpecificCommandDesc(TMMCCommandDesc& aDesc)

	{

	OstTraceFunctionEntry0( DUP2_DSDSESSION_FILLSDSPECIFICCOMMANDDESC_ENTRY );

	aDesc.iSpec = FindCommandSpec(SdSpecificCmdSpecTable, aDesc.iCommand);

	aDesc.iFlags = 0;

	aDesc.iBytesDone = 0;

	OstTraceFunctionExit0( DUP2_DSDSESSION_FILLSDSPECIFICCOMMANDDESC_EXIT );

	}

// ======== DSDStack ========

EXPORT_C TInt DSDStack::Init()

	{

	OstTraceFunctionEntry1( DSDSTACK_INIT_ENTRY, this );

	TInt ret = DMMCStack::Init();

	OstTraceFunctionExitExt( DSDSTACK_INIT_EXIT, this, ret );

	return ret;

	}

const TInt KMaxRCASendLoops=3;

const TUint KSDMaxPollAttempts=25;

EXPORT_C TMMCErr DSDStack::AcquireStackSM()

//

// This macro acquires new cards in an SD Card - star topology stack.

// This means each card has its own CMD and DAT lines and can be addressed

// individually by the Controller in turn. Commands can also be broadcast 

// simultaneously to the entire stack. 

// It starts with the Controller reading the operating conditions of each 

// card in the stack (SEND_OP_COND - ACMD41). Then, the following

// initialisation sequence is performed to each card in turn:-

// New cards in the stack are identified (ALL_SEND_CID - CMD2) and each one

// is requested to publish a relative card address (SEND_RCA - CMD3). Finally,

// the card specific data (SEND_CSD - CMD9) is read from each card.

// Note that the initialization of MMC cards are supported by this function

// if they are encountered. These require a slightly different init. procdure.

//

	{

		enum states

			{

			EStBegin=0,

			EStNextFullRange,

			EStSendCIDIssued,

			EStIssueSendRCA,

			EStSendRCACheck,

			EStRCADone,

			EStMoreCardsCheck,

			EStEnd

			};

		DMMCSession& s=Session();

		OstTrace1( TRACE_INTERNALS, DSDSTACK_ATTACHCARDSM, "Current session = 0x%x", &s );

	SMF_BEGIN

		OstTrace0( TRACE_INTERNALS, DSDSTACK_ATTACHCARDSM1, "EStBegin" );

        __KTRACE_OPT(KPBUS1, Kern::Printf(">DSDStack::AcquireStackSM()"));

		iRCAPool.ReleaseUnlocked();

		iCxCardCount=0; 		// Reset current card number

	SMF_STATE(EStNextFullRange)

		OstTrace0( TRACE_INTERNALS, DSDSTACK_ATTACHCARDSM2, "EStNextFullRange" );

		iCxCardType = ESDCardTypeUnknown;

		AddressCard(iCxCardCount); 	// Address the next card

		// Before issueing commands, see if there's actually a card present

		if (!CardDetect(iCxCardCount))

			SMF_GOTOS(EStMoreCardsCheck)

		// Card Previously Marked as Corrupt do not re-initialise	

		if ((CardArray().CardP(iCxCardCount)->iFlags)& KSDCardIsCorrupt)

		    {

            SMF_GOTOS(EStMoreCardsCheck)

		    }

		m.SetTraps(KMMCErrResponseTimeOut);

		SMF_INVOKES(InitialiseMemoryCardSMST, EStSendCIDIssued)

	SMF_STATE(EStSendCIDIssued)

		OstTrace0( TRACE_INTERNALS, DSDSTACK_ATTACHCARDSM3, "EStSendCIDIssued" );

		if( !err )

			{

			// The card responded with a CID. We need to initialise the

			// appropriate entry in the card array with the CID. 

			if (iCxCardType==ESDCardTypeIsSD)

				{

				// Now prepare to recieve an RCA from to the card

				CardArray().CardP(iCxCardCount)->iCID=s.ResponseP();

				DSDSession::FillSdSpecificCommandDesc(Command(), ESDCmdSendRelativeAddress,0); // SEND_RCA with argument just stuff bits

				m.ResetTraps();

				iCxPollRetryCount=0; // Init count of send RCA attempts 

				SMF_GOTOS(EStIssueSendRCA)

				}

			else