// 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:
// Class definitions for SDIO Stack and Session objects
// 
//

/**
 @file
 @internalTechnology
*/

#ifndef __SDIO_H__
#define __SDIO_H__

/**
  MMC_CPRM_SDIO : Defined in MMP or parent header 
  				  file to specify SD or CPRM Build
 */

#ifdef MMC_CPRM_SDIO
   #include "cprm.h"
   typedef DCPRMStack DStackBase;
   typedef DCPRMSession DSessionBase;
   const TUint32 KMinCustomSession = KCPRMMinCustomSession;
#else
   #include <drivers/sdio/dummyexp.h>
#endif

#include <drivers/sdio/sdiodefs.h>
#include <drivers/sdio/sdiocard.h>
#include <drivers/sdio/callback.h>
#include <drivers/sdio/interrupt.h>
#include <drivers/sdio/sdiopsu.h>
   
// Define this macro if function 0 does not support CMD53
// NB This should be mandatory for all cards !
#define SYMBIAN_FUNCTION0_CMD53_NOTSUPPORTED
   
#ifdef _DEBUG
#define TRACE_CCCR_INFO() TraceCCCRInfo();
#else
#define TRACE_CCCR_INFO() {};
#endif
      
////

class TSDIOCardArray;

enum TSDIOSessionTypeEnum
/** 
    @publishedPartner
	@released 
 
    These define the custom SDIO Macros
	@see DSDIOSession::FillDirectCommandDesc
*/
	{
	ECIMIoWriteDirect = KMinCustomSession,
	ECIMIoReadDirect,
	ECIMIoWriteMultiple,
	ECIMIoReadMultiple,
	ECIMIoModify,
	ECIMIoInterruptHandler,
	ECIMIoFindTuple,
	ECIMIoSetBusWidth,
	ECIMEnumEnd
	};

/**	
    @publishedPartner
	@released 
*/
const TUint KSDIOMaxSessionTypeNumber = ECIMEnumEnd;

/**	
	@publishedPartner
	@released 
*/
const TUint KSDIOMinCustomSession = KMinCustomSession + 1024;

enum TSDIOAppCmd
/** 
    @publishedPartner
	@released 
 
    These define the custom SDIO Application Commands
	@see DSDIOSession::FillAppCommandDesc
*/
	{
	ESDIOCmdOpCond          =  5,
	ESDIOCmdIoRwDirect      = 52,
	ESDIOCmdIoRwExtended	= 53,
	ESDIOCmdIoRwModify      = 0,	// This is a dummy command number
	};

enum TSDIOCardStateEnum
/**	
    @publishedPartner
	@released 
*/
	{
	ESDIOCardStateDis = 0, 		 // Initialise, Standby and Inactive State
	ESDIOCardStateCmd = 1 << 12, // CMD=DAT lines free - Command Waiting or Executing CMD52 in CMD state
	ESDIOCardStateTrn = 2 << 12, // TRN=Transfer - Command Executing with Data on DAT[0] or DAT[3:0]
	};

//// Bit definitions for R5 Error Response and State Mask

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrOutOfRange	  = KBit8;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrFunctionNumber = KBit9;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrGeneral		  = KBit11;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrIllegalCommand = KBit14;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrCrc			  = KBit15;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOErrorMask  		  = KSDIOErrOutOfRange |
									    KSDIOErrFunctionNumber |
									    KSDIOErrGeneral |
									    KSDIOErrIllegalCommand |
									    KSDIOErrCrc;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIOCurrentStateMask  = KBit12 | KBit13;

/**	
    @publishedPartner
	@released 
*/
const TUint32  KSDIODataMask  		  = 0x000000FF;

class TSDIOResponseR5
/**	
    @publishedPartner
	@released 
  
	TSDIOResponseR5 Class 
	Handles the processing of the R5 response to CMD52 and CMD53 commands
*/
	{
public:
	inline TSDIOResponseR5() {}
	inline TSDIOResponseR5(const TUint8*);
	inline TSDIOResponseR5(const TUint32&);
	inline operator TUint32() const;
	inline TUint32 Error() const;
	inline TSDIOCardStateEnum State() const;
	inline TUint8 Data() const;
private:
	TUint32 iData;
	};
	
//// CIS Constants

/**	
    @publishedPartner
	@released 
*/
const TUint32 KSdioCisAreaMin			=0x0001000;	// Minimum address of CIS area

/**	
    @publishedPartner
	@released 
*/
const TUint32 KSdioCisAreaMax			=0x0017FFF;	// Maximum address of CIS area

class TSDIOTupleInfo
/** 
    @publishedPartner
	@released 
  
    TSDIOTupleInfo Class 
    Contains information used when searching and processing CIS tuples
*/
	{
public:
	TUint32 iAddress;	/// Address of the tuple
	TUint8  iTupleId;	/// Tuple ID
	TUint8  iLength;	/// Tuple Link (length)
	};
	
struct TSDIOFragInfo
    {
    TUint8* iAddr;
    TUint32 iSize;
    }; 	
    
class DSDIOSession : public DSessionBase
/** 
  DSDIOSession Class
  
  This class represents a command or data session to a card's function
*/
	{
public:
	enum TPanic
		{
		ESDIOSessionOutOfRange,
		ESDIOSessionBadParameter,
		ESDIOSessionBadLength
		};
public:
	inline DSDIOSession(const TMMCCallBack& aCallBack);
	inline DSDIOSession(const TMMCCallBack& aCallBack, TUint8 aFunctionNumber);
	
	IMPORT_C virtual ~DSDIOSession();

	IMPORT_C void SetupCIMIoWrite(TUint32 aAddr, TUint8 aWriteVal, TUint8* aReadDataP);
	IMPORT_C void SetupCIMIoRead(TUint32 aAddr, TUint8* aReadDataP);
	IMPORT_C void SetupCIMIoWriteMultiple(TUint32 aAddr, TUint32 aLen, TUint8* aDataP, TBool aInc);
	IMPORT_C void SetupCIMIoReadMultiple(TUint32 aAddr, TUint32 aLen, TUint8* aDataP, TBool aInc);
	IMPORT_C void SetupCIMIoModify(TUint32 aAddr, TUint8 aSet, TUint8 aClr, TUint8* aReadDataP);

	void SetupCIMIoInterruptHandler(TUint8* aPendingDataP);
	void SetupCIMIoFindTuple(TSDIOTupleInfo* aTupleInfoP);
	void SetupCIMIoSetBusWidth(TInt aBusWidth);

	IMPORT_C static void FillAppCommandDesc(TMMCCommandDesc& aDesc, TSDIOAppCmd aCmd);
	IMPORT_C static void FillAppCommandDesc(TMMCCommandDesc& aDesc, TSDIOAppCmd aCmd, TMMCArgument aArg);

	void FillDirectCommandDesc(TMMCCommandDesc& aDesc, TSDIOSessionTypeEnum aSessType, TUint8 aFunction, TUint32 aAddr, TUint8 aWriteVal, TUint8* aReadDataP, TUint32 aLen = 1);
	void FillExtendedCommandDesc(TMMCCommandDesc& aDesc, TSDIOSessionTypeEnum aSessType, TUint8 aFunction, TUint32 aAddr, TUint32 aLen, TUint8* aDataP, TBool aInc);
	void FillIoModifyCommandDesc(TMMCCommandDesc& aDesc, TUint8 aFunction, TUint32 aAddr, TUint8 aSet, TUint8 aClr, TUint8* aDataP);

	inline TUint8 FunctionNumber() const;
	inline void   SetFunctionNumber(TUint8 aFunctionNumber);

	inline void SetCallback(const TMMCCallBack& aCallBack);

protected:
	IMPORT_C virtual TMMCSMSTFunc GetMacro(TInt aSessNum) const;
	inline void UnblockInterrupt(TMMCErr aReason);
	
	void SetupCIMIoChunkParams(DChunk* aChunk);
	void ClearCIMIoChunkParams();

private:
	IMPORT_C static void FillAppCommandDesc(TMMCCommandDesc& aDesc);

	inline void FillAddressParam(TUint32& aParam, TUint8 aFunction, TUint32 aAddr);
	inline void ModifyBits(TUint8& aValue);

	static void Panic(DSDIOSession::TPanic aPanic);

private:
    //
    // Dummy functions to maintain binary compatibility
    IMPORT_C virtual void Dummy1();
    IMPORT_C virtual void Dummy2();
    IMPORT_C virtual void Dummy3();
    IMPORT_C virtual void Dummy4();
	
private:
	TUint8 iFunctionNumber;
	
	TUint8 iSetBits;	// ONLY used in the ECIMIoModify session
	TUint8 iClrBits;	// ONLY used in the ECIMIoModify session
	
	TUint32 iMaxBlockSize;		// Maximum number of bytes per CMD53 (byte OR block mode)
	TUint32 iNumBlocks; 		// Number of blocks remaining to transfer for this session
	TUint32 iNumBytes;			// Number of bytes remaining to transfer for this session
	
	TUint32 iCrrFrg;              // Current memory fragment in use
	TUint32 iCrrFrgRmn;           // Reminaing space in current memory fragment
	TSDIOFragInfo* iFrgPgs;     // Multiple Memory Fragment information
	
	DChunk*  iChunk;            // Chunk which is to be used to host data transfer
	
	friend class DSDIOStack;
	friend class TSDIOInterruptController;

private:
    //
    // Reserved members to maintain binary compatibility
    TInt iReserved[4];	
	};


class DSDIOStack : public DStackBase
/** 
  DSDIOStack Class

  The DSDIO stack which drives operation of the SDIO card
*/
	{
public:
	enum TSDIOBlockingCondition
		/** These define the SDIO Blocking Conditions */
		{
		ESDIOBlockOnCommand,
		ESDIOBlockOnData
		};
		
	enum TPanic
		/** Various Panic Codes */
		{
		ESDIOStackBadCommand,
		ESDIOStackBadParameter,
		ESDIOStackBadLength,
		ESDIOStackOverlappedSession
		};
		
public:
	inline DSDIOStack(TInt aBus, DMMCSocket* aSocket);
	
	inline DSDIOSession& SDIOSession();
	inline TSDIOCardArray& CardArray() const;

	IMPORT_C virtual TInt Init();
	IMPORT_C virtual DMMCSession* AllocSession(const TMMCCallBack& aCallBack) const;

protected:
	IMPORT_C virtual TMMCErr AcquireStackSM();
	IMPORT_C virtual TMMCErr CIMReadWriteBlocksSM();

	IMPORT_C TMMCErr CIMIoReadWriteDirectSM();
	IMPORT_C TMMCErr CIMIoReadWriteExtendedSM();
	IMPORT_C TMMCErr CIMIoModifySM();

	static TMMCErr CIMIoReadWriteDirectSMST(TAny* aStackP);
	static TMMCErr CIMIoReadWriteExtendedSMST(TAny* aStackP);
	static TMMCErr CIMIoModifySMST(TAny* aStackP);
	static TMMCErr CIMIoInterruptHandlerSMST(TAny* aStackP);
	static TMMCErr CIMIoFindTupleSMST(TAny* aStackP);
	static TMMCErr CIMIoSetBusWidthSMST(TAny* aStackP);
	static TMMCErr CIMReadWriteMemoryBlocksSMST(TAny* aStackP);

	static TMMCErr CIMIoIssueCommandCheckResponseSMST(TAny* aStackP);
	inline TMMCErr CIMIoIssueCommandCheckResponseSM();

    static TMMCErr BaseModifyCardCapabilitySMST(TAny* aStackP);
    IMPORT_C virtual TMMCErr ModifyCardCapabilitySM();

    IMPORT_C void HandleSDIOInterrupt(TUint aCardIndex);
	
	IMPORT_C void BlockIOSession(TSDIOBlockingCondition aBlockCond);		
	IMPORT_C DSDIOSession* UnblockIOSession(TSDIOBlockingCondition aBlockCond, TMMCErr aError);
	
	inline DSDIOSession* DataSessionP();
	inline DSDIOSession* CommandSessionP();

/**
	@publishedPartner
	@released

	Sets the card currently in use (i.e. the intended recipient of any commands).
	Must be implemented by the Platform Specific Layer
	@param aCardNumber The card number selected.
*/
	virtual void AddressCard(TInt aCardNumber) = 0;

/**
	@publishedPartner
	@released

	Indicates that the PSL should enable and notify the PIL of SDIO interrupts.
	Must be implemented by the Platform Specific Layer
*/
	virtual void EnableSDIOInterrupt(TBool aEnable) = 0;

/**
	@publishedPartner
	@released

	Returns the maximum supported IO block size
	Must be implemented by the Platform Specific Layer
	@return The maximum supported IO block length
*/
	virtual TUint32 MaxBlockSize() const = 0;
	
private:
	static TMMCErr ConfigureIoCardSMST(TAny* aStackP);

	static inline TInt ExtractSendOpCondResponse(TUint32 aResponseR4, TUint8& aFunctionCount, TBool& aMemPresent, TUint32& aIoOCR);
	
	static TMMCErr CIMGetIoCommonConfigSMST(TAny* aStackP);
	static TMMCErr CIMReadFunctionBasicRegistersSMST(TAny* aStackP);
	
	TMMCErr ConfigureIoCardSM();
	TMMCErr GetIoCommonConfigSM();
	TMMCErr ReadFunctionBasicRegistersSM();
	TMMCErr CIMIoInterruptHandlerSM();
	TMMCErr CIMIoFindTupleSM();
	TMMCErr CIMIoSetBusWidthSM();
		
	static void Panic(DSDIOStack::TPanic aPanic);
	
#ifdef _DEBUG
	void TraceCCCRInfo();
#endif

private:
	TInt iSpare;
	
	TUint8 iFunctionCount;				// Used during SDIO function detection
	TUint8 iFunctionScan;				// Used during SDIO function detection
	TBool  iMemoryPresent;				// Used during SDIO Card Initialisation
	TUint8 iSDStatus[KSDStatusBlockLength];
	TUint8 iBufCCCR[KSDIOCccrLength];
	TUint8 iBufFBR[KSDIOFbrLength];
	
	DSDIOSession* iDataSessionP;
	DSDIOSession* iCmdSessionP;
	
	TInt iBlockedSessions;	

	friend class DSDIOSession;
	friend class TSDIOInterruptController;

private:
    //
    // Dummy functions to maintain binary compatibility
    IMPORT_C virtual void Dummy1();
    IMPORT_C virtual void Dummy2();
    IMPORT_C virtual void Dummy3();
    IMPORT_C virtual void Dummy4();
    //
    // Reserved members to maintain binary compatibility
    TInt iReserved[4];
    };

class DSDIOSocket : public DMMCSocket
/**
 * This DPBusSocket derived object oversees the power supplies
 * and media change functionality of DSDIOSTACK Objects.
 *
 * Special consideration is required for SDIO Cards to ensure
 * that IO devices are powered down considerately (as opposed
 * to simply removing the power as in the case of memory cards)
 */
	{
public:
	/** TODO: Move this inline? */
	IMPORT_C DSDIOSocket(TInt aSocketNumber, TMMCPasswordStore* aPasswordStore);
	
	// Functions inherited from DPBusSocket
	TInt Init();
	void InitiatePowerUpSequence();
	TBool CardIsPresent();
	void Reset1();
	void Reset2();

	// Low-power sleep mode control
	IMPORT_C void RequestAsyncSleep();
	IMPORT_C void SleepComplete();

private:
	static void SleepDFC(TAny* aSelfP);
	void SetSleep(TBool aIsSleeping);

protected:
	void ResetAndPowerDown();
	void SignalSleepMode();	

private:
	TInt    iRequestSleepCount;
	TBool   iSleeping;	
	TDfcQue iSleepDfcQ;
	TDfc    iSleepDfc;

	friend class DSDIOPsu;
	friend class DSDIOStack;

	//
	// Reserved members to maintain binary compatibility
	TInt iReserved[4];
	};

#include <drivers/sdio/sdio.inl>

#endif	// #ifndef __SDIO_H__