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

//

#include <drivers/sdio/sdio.h>

#include <drivers/sdio/cisreader.h>

#include <drivers/sdio/function.h>

#include <drivers/sdio/regifc.h>

#include "utraceepbussdio.h"

#ifdef __SMP__

TSpinLock SDIOLock(TSpinLock::EOrderGenericIrqHigh0);

#endif

#if !defined(__WINS__)

#define DISABLEPREEMPTION TUint irq = __SPIN_LOCK_IRQSAVE(SDIOLock);

#define RESTOREPREEMPTION __SPIN_UNLOCK_IRQRESTORE(SDIOLock,irq);

#else

#define DISABLEPREEMPTION

#define RESTOREPREEMPTION										   

#endif

// Some SDIO cards don't respond to an I/O reset command, but sending ECmdGoIdleState 

// after the timeout has the effect of putting the card into SPI mode.

// Undefine this macro for these cards.

#define __SEND_CMD0_AFTER_RESETIO_TIMEOUT__

// The ReadWriteExtendSM can handle fragmented RAM, this functionity may not be required 

// with the introduction of defragment RAM/3rd party driver support features

#define __FRAGMENTED_RAM_SUPPORT

// Temporarily override the MMC version of SMF_BEGIN to add Tracing to the state machine

#undef SMF_BEGIN 

#define SMF_BEGIN TMMCStateMachine& m=Machine();const TMMCErr err=m.SetExitCode(0);\

 	for(;;){SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EState), "SDIOStack state change, m.State = %d", m.State()));/*//@SymTraceDataInternalTechnology*/\

        switch(m.State()){case EStBegin:{if(err) (void)0;

// ======== DSDIOStack ========

EXPORT_C TInt DSDIOStack::Init()

/**	

@publishedPartner

@released

Initialize the stack

*/

	{

	return DStackBase::Init();

	}

TMMCErr DSDIOStack::ConfigureIoCardSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->ConfigureIoCardSM(); }

TMMCErr DSDIOStack::CIMGetIoCommonConfigSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->GetIoCommonConfigSM(); }

TMMCErr DSDIOStack::CIMReadFunctionBasicRegistersSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->ReadFunctionBasicRegistersSM(); }

TMMCErr DSDIOStack::CIMIoIssueCommandCheckResponseSMST(TAny* aStackP)

	{ return( static_cast<DSDIOStack *>(aStackP)->CIMIoIssueCommandCheckResponseSM() ); }

TMMCErr DSDIOStack::CIMIoReadWriteDirectSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->CIMIoReadWriteDirectSM(); }

TMMCErr DSDIOStack::CIMIoReadWriteExtendedSMST(TAny* aStackP)

	{return static_cast<DSDIOStack*>(aStackP)->CIMIoReadWriteExtendedSM(); }

TMMCErr DSDIOStack::CIMIoModifySMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->CIMIoModifySM(); }

TMMCErr DSDIOStack::CIMIoInterruptHandlerSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->CIMIoInterruptHandlerSM(); }

TMMCErr DSDIOStack::CIMIoFindTupleSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->CIMIoFindTupleSM(); }

TMMCErr DSDIOStack::CIMIoSetBusWidthSMST(TAny* aStackP)

	{ return static_cast<DSDIOStack*>(aStackP)->CIMIoSetBusWidthSM(); }

TMMCErr DSDIOStack::CIMReadWriteMemoryBlocksSMST(TAny* aStackP)

	{ return( static_cast<DSDIOStack *>(aStackP)->DSDStack::CIMReadWriteBlocksSM() ); }

const TInt  KMaxRCASendLoops=3;

const TUint32 KDefaultFn0BlockSize     = 0x40;

const TUint8 KSDIONoTranSpeed		   = 0x00;

const TUint8 KSDIODefaultLowTranSpeed  = 0x48;

const TUint8 KSDIODefaultHighTranSpeed = 0x32;

EXPORT_C TMMCErr DSDIOStack::AcquireStackSM()

/**

This macro acquires new cards in an SDIO Card stack.

This is an extension of the DSDStack::AcquireStackSM state machine

function, and handles the SDIO initialisation procedure as described

in Version 1.10f of the the SDIO Card Specification.

@return TMMCErr Error Code

*/

	{

	TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIODSDIOStackAcquireStack, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk

	enum states

			{

			EStBegin=0,

			EStInitIOReset,

			EStIOReset,

			EStCheckIOResetResponse,

			EStInitIOSendOpCond,

			EStInitIOCheckResponse,

			EStInitIOSetWorkingOCR,

			EStInitIOCheckOcrResponse,

			EStInitMemoryCard,

			EStHandleRcaForCardType,

			EStIssueSendRCA,

			EStIssueSetRCA,

			EStSendRCACheck,

			EStRCADone,

			EStConfigureMemoryCardDone,

			EStGoInactive,

			EStCheckNextCard,

			EStEnd

			};

		DSDIOSession& s=SDIOSession();

		DMMCPsu* psu=(DMMCPsu*)MMCSocket()->iVcc;

	SMF_BEGIN

		iRCAPool.ReleaseUnlocked();

		iCxCardCount=0; 		// Reset current card number

		CardArray().Card(iCxCardCount).RCA() = 0x0000;

	SMF_STATE(EStInitIOReset)

		// EStInitIOReset : Reset the IO Card.	

		//

		// We expect the card to be reset before enumeration in order for the

		// card to be in the default state (ie- functions disabled, 1-bit mode)

		//

		// Resets the IO card by setting RES bit in IO_ABORT reg of the CCCR

		// 

		iFunctionCount  = 0;

		iMemoryPresent  = EFalse;

		if (!CardDetect(iCxCardCount))

			{

			SMF_GOTOS(EStCheckNextCard)

			}

        iCxCardType = CardType(MMCSocket()->iSocketNumber, iCxCardCount);

        if (iCxCardType!=ESDCardTypeUnknown)

            {

            // Skip the SDIO Protocol Seq.

            SMF_GOTOS(EStInitMemoryCard);

            }

		TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIODSDIOStackPSLCalledAddressCard, reinterpret_cast<TUint32>(this), iCxCardCount); // @SymTraceDataPublishedTvk

		AddressCard(iCxCardCount);

		TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIODSDIOStackPSLAddressCardReturned, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk

	SMF_STATE(EStIOReset)

		// EStResetIo

		m.SetTraps(KMMCErrAll);

		s.iCardP = static_cast<TSDIOCard*>(CardArray().CardP(iCxCardCount));

		s.FillDirectCommandDesc(Command(), ECIMIoWriteDirect, 0x00, KCCCRRegIoAbort, KSDIOCardIoAbortReset, NULL);

		SMF_INVOKES(IssueCommandCheckResponseSMST, EStCheckIOResetResponse)

	SMF_STATE(EStCheckIOResetResponse)

		// EStCheckIOResetResponse

		DoSetBusWidth(KSDBusWidth1);

#ifdef __SEND_CMD0_AFTER_RESETIO_TIMEOUT__

		if(err)

			{

			m.SetTraps(KMMCErrAll);

			SMF_INVOKES(GoIdleSMST, EStInitIOSendOpCond)

			}

#endif

		// Drop through to EStInitIOSendOpCond if reset OK

	SMF_STATE(EStInitIOSendOpCond)

		// EStInitIOSendOpCond : Determine the capabilities of the card.

		//														

		// Determine the basic capabilities of the card by sending the card

		// IO_SEND_OP_COND (CMD5) with ARG=0x0000, which should respond with

		// the number of supported IO functions and the supported OCR.

		if(err)

			{

			SMF_GOTOS(EStInitMemoryCard)

			}

		iCxPollRetryCount=0;

		iConfig.RemoveMode( KMMCModeEnableTimeOutRetry );

		m.SetTraps(KMMCErrResponseTimeOut);

		DSDIOSession::FillAppCommandDesc(Command(), ESDIOCmdOpCond, 0x0000);

		SMF_INVOKES(ExecCommandSMST, EStInitIOCheckResponse)

	SMF_STATE(EStInitIOCheckResponse)

		// EStInitIOCheckResponse : Check the response to IO_SEND_OP_COND (CMD5)				

		//																				

		// The R4 response shall contain the following information:									

		//																				

		// 1. Number of IO Functions : 0 = no IO present, 1 = Single Function, >1 = Multi-Function Card

		// 2. Memory Present		 : 1 = Memory is present (if nIO>0, then this is a Combo Card)	

		// 3. IO OCR				 : The OCR for the IO portion of the card (Use ACMD41 for Memory OCR)

		//

		// If the CMD5 response has timed out, then this can't be an SDIO card.

		// We should now continue and try to detect the presence of a memory card.

		if (err & KMMCErrResponseTimeOut)

			{

			SMF_GOTOS(EStInitMemoryCard)

			}

		//

		// Check the R4 response for the number of IO functions and presence of Memory

		//

		iFunctionCount = 0;

		iMemoryPresent = EFalse;

		TUint32 ioOCR = 0x00000000;

		//

		// No need to test IO_READY yet, as we have not yet set the OCR

		//

		(void)ExtractSendOpCondResponse(TMMC::BigEndian32(s.ResponseP()), iFunctionCount, iMemoryPresent, ioOCR);

		if(iFunctionCount == 0)

			{

			// F=0, MP=1 => Initialise Memory Controller

			// F=0, MP=0 => Go Inactive

			SMF_GOTOS(iMemoryPresent ? EStInitMemoryCard : EStGoInactive)

			}

		else

			{

			//

			// IO is ready and there is at least one function present, so now determine a

			// suitable setting for the IO OCR based on the capabilities of our hardware.

			//

			iCurrentOpRange &= ioOCR;

			if (iCurrentOpRange==0)

				{

				// The card is incompatible with our h/w

				SMF_GOTOS(iMemoryPresent ? EStInitMemoryCard : EStGoInactive)

				}

			}

		// Reset retry count. Timeout to 1S

		iCxPollRetryCount=0;  

		//...drop through to next state (EStInitIOSetWorkingOCR)

	SMF_STATE(EStInitIOSetWorkingOCR)

		// EStInitIOSetWorkingOCR :	

		//

		// The OCR range is supported by our hardware, so re-issue 

		// IO_SEND_OP_COND (CMD5) with our chosen voltage range

		//

		m.SetTraps(KMMCErrResponseTimeOut);

		DSDIOSession::FillAppCommandDesc(Command(), ESDIOCmdOpCond, TMMCArgument(iCurrentOpRange));

		SMF_INVOKES(ExecCommandSMST, EStInitIOCheckOcrResponse)

	SMF_STATE(EStInitIOCheckOcrResponse)

		// EStInitIOCheckOcrResponse : Verify the response to IO_SEND_OP_COND (CMD5) with ARG=IO_OCR

		//										

		// Verifies that the OCR has been successfully accepted by the SDIO Card (within 1 Second)

		if(err == KMMCErrResponseTimeOut)

			{

			// Previous CMD5 (Arg=0000) worked, but this one failed

			// with no response, so give up and go inactive.

			SMF_GOTOS(EStGoInactive)

			}

		//

		// Check the R4 response for the number of IO functions and presence of Memory

		//

		TUint32 ioOCR = 0x00000000;

		if(ExtractSendOpCondResponse(TMMC::BigEndian32(s.ResponseP()), iFunctionCount, iMemoryPresent, ioOCR) != KErrNotReady)

			{

			//

			// The OCR has been communicated successfully to the card,

			// so now adjust the hardware's PSU accordingly

			//

			psu->SetVoltage(iCurrentOpRange);

			if (psu->SetState(EPsuOnFull) != KErrNone)

				{

				return(KMMCErrHardware);

				}

			// We can be sure that this is at least an IO Card

			CardArray().CardP(iCxCardCount)->iFlags |= KSDIOCardIsIOCard;

			//

			// Restore the original error conditions and timeout settings

			//

			iConfig.SetMode( EffectiveModes(s.iConfig) & KMMCModeEnableTimeOutRetry );

			iConfig.SetPollAttempts(KMMCMaxPollAttempts);

			//

			// Initialise memory if present, otherwise configure the IO Card

			//

			iCxPollRetryCount = 0;	// Re-Initialise for RCA poll check

			SMF_GOTOS(iMemoryPresent ? EStInitMemoryCard : EStIssueSendRCA)

			}

		else

			{

			//

			// IO Not Ready (IORDY=0) - Still powering up

			//

			m.ResetTraps();

			if ( ++iCxPollRetryCount > iConfig.OpCondBusyTimeout() )

				{

				// IO Timeout - Try to initialise memory

				SMF_GOTOS(iMemoryPresent ? EStInitMemoryCard : EStGoInactive)

				}

			SMF_INVOKES(RetryGapTimerSMST, EStInitIOSetWorkingOCR)

			}

	SMF_STATE(EStInitMemoryCard)

		// EStInitMemoryCard										

		//														

		// Initialise the Memory Card or the Memory portion of a Combo Card

		//													

		// If the IO portion of a Combo Card has just been initialised,

		// then the card shall already be stored in the Card Array and the

		// supported voltage settings present in iCurrentOpRange, which

		// shall be used in the SDCARD Initialisation state machine

		m.SetTraps(KMMCErrResponseTimeOut);

		SMF_INVOKES(InitialiseMemoryCardSMST, EStHandleRcaForCardType)

	SMF_STATE(EStHandleRcaForCardType)

		// EStHandleRcaForCardType

		//	

		// At this stage, the SDIO controller should have determined if

		// the card contains IO functionality, and the SD controller should

		// have determined the type of memory present.  We now combine these

		// two factors to work out the actual card type.

		m.ResetTraps();

		if(err)

			{

			// Memory timeout - check next card

			SMF_GOTOS(EStConfigureMemoryCardDone);

			}

		TSDIOCard& ioCard = CardArray().Card(iCxCardCount);

		if(!(ioCard.IsSDCard() || ioCard.IsIOCard()))

			{

			SMF_GOTOS(EStIssueSetRCA)

			}

 		ioCard.iCID=s.ResponseP();

		iCxPollRetryCount = 0;	// Re-Initialise for RCA poll check

		// Drop through to EStIssueSendRCA if the card is an SD or IO card

	SMF_STATE(EStIssueSendRCA)

		// EStIssueSendRCA				

		//								

		// Sends SEND_RCA (CMD3) in SD Mode

		s.FillCommandDesc(ECmdSetRelativeAddr,0);

		// override default MMC settings

		Command().iSpec.iCommandType=ECmdTypeBCR;

		Command().iSpec.iResponseType=ERespTypeR6;

		m.ResetTraps();

		SMF_INVOKES(ExecCommandSMST,EStSendRCACheck)

	SMF_STATE(EStIssueSetRCA)

		// EStIssueSetRCA						

		//									

		// Sends SET_RCA (CMD3) for MMC Cards

		//

		// The card array allocates an RCA, either the old RCA

		// if we have seen this card before, or a new one.

		TRCA rca;

		CardArray().AddCardSDMode(iCxCardCount, s.ResponseP(), &rca);

		// Now assign the new RCA to the card

		s.FillCommandDesc(ECmdSetRelativeAddr,TMMCArgument(rca));

		SMF_INVOKES(ExecCommandSMST,EStRCADone)

	SMF_STATE(EStSendRCACheck)

		// EStIssueSendRCA									

		//													

		// Checks response to SEND_RCA (CMD3) and selects the card	

		//

		// We need to check that the RCA recieved from the card doesn't clash

		// with any others in this stack. RCA is first 2 bytes of response buffer (in big endian)

		TInt err = KErrNone;	

		TSDIOCard& ioCard = CardArray().Card(iCxCardCount);

		TRCA rca=(TUint16)((s.ResponseP()[0]<<8) | s.ResponseP()[1]);

		if(ioCard.IsIOCard())

			{

			err = CardArray().AddSDIOCard(iCxCardCount, rca, iFunctionCount);

			}

		else

			{

			err = CardArray().AddSDCard(iCxCardCount, rca);

			}

		if(err != KErrNone)

			{

			if(++iCxPollRetryCount<KMaxRCASendLoops)

				{

				SMF_GOTOS(EStIssueSendRCA)

				}

			else

				{

				// Memory only cards cannot accept CMD15 until CMD3 has been succesfully

				// recieved and we have entered STBY state.  IO Cards can accept RCA=0000

				SMF_GOTOS(ioCard.IsIOCard() ? EStGoInactive : EStCheckNextCard)

				}

			}

		// ...drop through to next state (EStRCADone)

	SMF_STATE(EStRCADone)

		// Cards is initialised so get its CSD

		m.ResetTraps();	// We are no longer processing any errors

		TSDIOCard& ioCard = CardArray().Card(iCxCardCount);

		if(ioCard.IsIOCard() && !ioCard.IsSDCard())

			{

			// IO Only Card - Jump straight to the IO Configuration SM

			SMF_INVOKES(ConfigureIoCardSMST, EStCheckNextCard)

			}

		else

			{

			// Initialise cards containing memory first, then configure IO.

			// This ensures that the memory portion will have set the 

			// bus with via ACMD6 prior to setting the width of the IO controller.

			// The SDIO specification states that the bus width of a combo card

			// shall not change until BOTH controllers have been notified.

			// (ie - ACMD6 + IO_BUS_WIDTH)

			SMF_INVOKES(ConfigureMemoryCardSMST, EStConfigureMemoryCardDone)

			}

	SMF_STATE(EStConfigureMemoryCardDone)

		if(CardArray().Card(iCxCardCount).IsComboCard())

			{

			// Combo Card - Need to initialise IO after Memory			

			SMF_INVOKES(ConfigureIoCardSMST, EStCheckNextCard)

			}

		SMF_GOTOS(EStCheckNextCard)

	SMF_STATE(EStGoInactive)

		// EStGoInactive

		//				

		// Issues CMD15 to enter Inactive state in case of initialisation errors

		// IO Cards accept CMD15 with RCA=0, so it's OK if we enter here before

		// issuing CMD3 - However, this is not true for Memory Only Cards

		TSDIOCard& ioCard = CardArray().Card(iCxCardCount);

		s.FillCommandDesc(ECmdGoInactiveState, TMMCArgument(ioCard.iRCA));

		SMF_INVOKES(ExecCommandSMST, EStCheckNextCard)

	SMF_STATE(EStCheckNextCard)

		// EStCheckNextCard

		//				

		// Checks the next card in the stack (or exits)

		if (++iCxCardCount < (TInt)iMaxCardsInStack)

			{

			// Check the next card

			SMF_GOTOS(EStInitIOReset)

			}

		else

			{

			 // Set back to broadcast mode and exit

			TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIODSDIOStackPSLCalledAddressCard, reinterpret_cast<TUint32>(this), KBroadcastToAllCards); // @SymTraceDataPublishedTvk

			AddressCard(KBroadcastToAllCards);

			TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIODSDIOStackPSLAddressCardReturned, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk