// 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:

//

// WARNING: This file contains some APIs which are internal and are subject

//          to change without noticed. Such APIs should therefore not be used

//          outside the Kernel and Hardware Services package.

//

/**

 A static function that takes the 4 bytes that are stored in a memory location

 in ascending address order, and returns them as a 32-bit unsigned integer

 in big-endian format.

 @param aPtr A pointer to the memory location containing the 4 bytes to be stored.

 @return A 32 bit unsigned integer containing the 4 bytes in big-endian format.

*/

inline TUint32 TMMC::BigEndian32(const TUint8* aPtr)

	{return( (aPtr[0]<<24) | (aPtr[1]<<16) | (aPtr[2]<<8) | (aPtr[3]) );}

/**

A static function that takes the specified 32-bit unsigned integer, assumed to

be in big-endian format, and stores this into the specified memory location.

@param aPtr A pointer to a 4 byte memory location which is to contain

            the unsigned integer.

@param aVal A 32 bit unsigned integer in big-endian format.

*/

inline void TMMC::BigEndian4Bytes(TUint8* aPtr, TUint32 aVal)

	{

	aPtr[0] = (TUint8)(aVal >> 24);

	aPtr[1] = (TUint8)(aVal >> 16);

	aPtr[2] = (TUint8)(aVal >> 8);

	aPtr[3] = (TUint8)aVal;

	}

//	--------  class TCID  --------

inline TCID::TCID(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCIDLength);}

inline TCID& TCID::operator=(const TCID& aCID)

	{memcpy(&iData[0], &aCID.iData[0], KMMCCIDLength); return(*this);}

inline TCID& TCID::operator=(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCIDLength); return(*this);}

inline TBool TCID::operator==(const TCID& aCID) const

	{return(memcompare(&iData[0],KMMCCIDLength,&aCID.iData[0],KMMCCIDLength)==0);}

inline TBool TCID::operator==(const TUint8* aPtr) const

	{return(memcompare(&iData[0],KMMCCIDLength,aPtr,KMMCCIDLength)==0);}

inline void TCID::Copy(TUint8* aPtr) const

	{memcpy(aPtr, &iData[0], KMMCCIDLength);}

inline TUint8 TCID::At(TUint anIndex) const

	{return(iData[KMMCCIDLength-1-anIndex]);}

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

inline TCSD::TCSD(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCSDLength);}

inline TCSD& TCSD::operator=(const TCSD& aCSD)

	{memcpy(&iData[0], &aCSD.iData[0], KMMCCSDLength); return(*this);}

inline TCSD& TCSD::operator=(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCCSDLength); return(*this);}

inline void TCSD::Copy(TUint8* aPtr) const

	{memcpy(aPtr, &iData[0], KMMCCSDLength);}

inline TUint8 TCSD::At(TUint anIndex) const		// anIndex byte in little-endian format

	{return(iData[KMMCCSDLength-1-anIndex]);}

// Raw field accessors.  Encoded values such as memory capacity are calulated in

// non-inline functions defined in ps_mmc.cpp.

inline TUint TCSD::CSDStructure() const		{return( CSDField(127,126) );}

inline TUint TCSD::SpecVers() const		{return( CSDField(125,122) );}

inline TUint TCSD::Reserved120() const		{return( CSDField(121,120) );}

inline TUint TCSD::TAAC() const			{return( CSDField(119,112) );}

inline TUint TCSD::NSAC() const			{return( CSDField(111,104) );}

inline TUint TCSD::TranSpeed() const		{return( CSDField(103,96) );}

inline TUint TCSD::CCC() const			{return( CSDField(95,84) );}

inline TUint TCSD::ReadBlLen() const		{return( CSDField(83,80) );}

inline TBool TCSD::ReadBlPartial() const	{return( CSDField(79,79) );}

inline TBool TCSD::WriteBlkMisalign() const	{return( CSDField(78,78) );}

inline TBool TCSD::ReadBlkMisalign() const	{return( CSDField(77,77) );}

inline TBool TCSD::DSRImp() const		{return( CSDField(76,76) );}

inline TUint TCSD::Reserved74() const		{return( CSDField(75,74) );}

inline TUint TCSD::CSize() const		{return( CSDField(73,62) );}

inline TUint TCSD::VDDRCurrMin() const		{return( CSDField(61,59) );}

inline TUint TCSD::VDDRCurrMax() const		{return( CSDField(58,56) );}

inline TUint TCSD::VDDWCurrMin() const		{return( CSDField(55,53) );}

inline TUint TCSD::VDDWCurrMax() const		{return( CSDField(52,50) );}

inline TUint TCSD::CSizeMult() const		{return( CSDField(49,47) );}

inline TUint TCSD::EraseGrpSize() const		{return( CSDField(46,42) );}

inline TUint TCSD::EraseGrpMult() const		{return( CSDField(41,37) );}

inline TUint TCSD::WPGrpSize() const		{return( CSDField(36,32) );}

inline TBool TCSD::WPGrpEnable() const		{return( CSDField(31,31) );}

inline TUint TCSD::DefaultECC() const		{return( CSDField(30,29) );}

inline TUint TCSD::R2WFactor() const		{return( CSDField(28,26) );}

inline TUint TCSD::WriteBlLen() const		{return( CSDField(25,22) );}

inline TBool TCSD::WriteBlPartial() const	{return( CSDField(21,21) );}

inline TUint TCSD::Reserved16() const		{return( CSDField(20,16) );}

inline TBool TCSD::FileFormatGrp() const	{return( CSDField(15,15) );}

inline TBool TCSD::Copy() const			{return( CSDField(14,14) );}

inline TBool TCSD::PermWriteProtect() const	{return( CSDField(13,13) );}

inline TBool TCSD::TmpWriteProtect() const	{return( CSDField(12,12) );}

inline TUint TCSD::FileFormat() const		{return( CSDField(11,10) );}

inline TUint TCSD::ECC() const			{return( CSDField(9,8) );}

inline TUint TCSD::CRC() const			{return( CSDField(7,1) );}

//	--------  class TExtendedCSD  --------

inline TExtendedCSD::TExtendedCSD()	// Default constructor

	{}				

inline TExtendedCSD::TExtendedCSD(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCExtendedCSDLength);}

inline TExtendedCSD& TExtendedCSD::operator=(const TExtendedCSD& aCSD)

	{memcpy(&iData[0], &aCSD.iData[0], KMMCExtendedCSDLength); return(*this);}

inline TExtendedCSD& TExtendedCSD::operator=(const TUint8* aPtr)

	{memcpy(&iData[0], aPtr, KMMCExtendedCSDLength); return(*this);}

inline TMMCArgument TExtendedCSD::GetWriteArg(TExtCSDAccessBits aAccess, TExtCSDModesFieldIndex aIndex, TUint aValue, TUint aCmdSet)

	{return TMMCArgument((aAccess << 24) | (aIndex << 16) | (aValue << 8) | (aCmdSet));}

inline TUint8* TExtendedCSD::Ptr() {return &iData[0];}

// Raw field accessors.  

// "Properties Segment" of Extended CSD - i.e. read-only fields

inline TUint TExtendedCSD::SupportedCmdSet() const {return iData[504];}

inline TUint TExtendedCSD::SectorCount() const {return(iData[212] | ((TUint)iData[213] << 8) | ((TUint)iData[214] << 16) | ((TUint)iData[215] << 24));}

inline TUint TExtendedCSD::MinPerfWrite8Bit52Mhz() const {return iData[210];}

inline TUint TExtendedCSD::MinPerfRead8Bit52Mhz() const {return iData[209];}

inline TUint TExtendedCSD::MinPerfWrite8Bit26Mhz_4Bit52Mhz() const {return iData[208];}

inline TUint TExtendedCSD::MinPerfRead8Bit26Mhz_4Bit52Mhz() const {return iData[207];}

inline TUint TExtendedCSD::MinPerfWrite4Bit26Mhz() const {return iData[206];}

inline TUint TExtendedCSD::MinPerfRead4Bit26Mhz() const {return iData[205];}

inline TUint TExtendedCSD::PowerClass26Mhz360V() const {return iData[203];}

inline TUint TExtendedCSD::PowerClass52Mhz360V() const {return iData[202];}

inline TUint TExtendedCSD::PowerClass26Mhz195V() const {return iData[201];}

inline TUint TExtendedCSD::PowerClass52Mhz195V() const {return iData[200];}

inline TUint TExtendedCSD::CardType() const {return iData[196];}

inline TUint TExtendedCSD::CSDStructureVer() const {return iData[194];}

inline TUint TExtendedCSD::ExtendedCSDRev() const {return iData[EExtendedCSDRevIndex];}

inline TUint TExtendedCSD::AccessSize() const {return iData[EAccessSizeIndex];}

inline TUint TExtendedCSD::HighCapacityEraseGroupSize() const {return iData[EHighCapacityEraseGroupSizeIndex];}

inline TUint TExtendedCSD::BootInfo() const {return iData[228];}

inline TUint TExtendedCSD::BootSizeMultiple() const {return iData[226];}

inline TUint TExtendedCSD::EraseTimeoutMultiple() const {return iData[223];}

inline TUint TExtendedCSD::ReliableWriteSector() const {return iData[222];}

inline TUint TExtendedCSD::HighCapacityWriteProtectGroupSize() const {return iData[221];}

inline TUint TExtendedCSD::SleepCurrentVcc() const {return iData[220];}

inline TUint TExtendedCSD::SleepCurrentVccQ() const {return iData[219];}

inline TUint TExtendedCSD::SleepAwakeTimeout() const {return iData[217];}

// "Modes Segment" of Extended CSD - i.e. modifiable fields

inline TUint TExtendedCSD::CmdSet() const {return iData[ECmdSetIndex];}

inline TUint TExtendedCSD::CmdSetRev() const {return iData[ECmdSetRevIndex];}

inline TUint TExtendedCSD::PowerClass() const {return iData[EPowerClassIndex];}

inline TUint TExtendedCSD::HighSpeedTiming() const {return iData[EHighSpeedInterfaceTimingIndex];}

inline TUint TExtendedCSD::BusWidthMode() const {return iData[EBusWidthModeIndex];}

inline TUint TExtendedCSD::BootConfig() const {return iData[EBootConfigIndex];}

inline TUint TExtendedCSD::BootBusWidth() const {return iData[EBootBusWidthIndex];}

inline TUint TExtendedCSD::EraseGroupDef() const {return iData[EEraseGroupDefIndex];}

//	--------  class TMMCStatus  --------

 /**

 * Constructor for TMMCStatus.

 * @param aPtr	A pointer to the memory location containing the 4 bytes to be stored. 

 				The 4 bytes corresponds to MMC card response. Refer to the MMC card specification for the possible values of response.

 */

inline TMMCStatus::TMMCStatus(const TUint8* aPtr) : iData(TMMC::BigEndian32(aPtr)) {}

/**

 * constructs the TMMCStatus object with value corresponding to MMC status register.

 * @param aData	Value corresponding to MMC status register.

 */

inline TMMCStatus::TMMCStatus(const TUint32& aData) : iData(aData) {}

/**

 * Gets the bitfield(32 bits) representing the MMC status register.

 * @return Value corresponding to MMC status register.

 */

inline TMMCStatus::operator TUint32() const {return(iData);}

/**

 * Gets the error status.

 * For the possible values, refer to the MMC card R1 Response. 

 * @see DMMCStack

 * @return MMC card error status.

 */

inline TUint32 TMMCStatus::Error() const { return(iData & KMMCStatErrorMask); }

/**

 * Gets the MMC card's current state machine.

 * For the possible values of the state machine, refer to the MMC card specification.

 * @return The current state of the state machine.

 */

inline TMMCardStateEnum TMMCStatus::State() const

	{ return((TMMCardStateEnum)(iData & KMMCStatCurrentStateMask)); }

/**

 * Replace the MMC card's current state with supplied value

 * @param aState The new MMC card State

 */

inline void TMMCStatus::UpdateState(TMMCardStateEnum aState)

	{ 

	iData &= ~KMMCStatCurrentStateMask;

	iData |= aState;

	}

//	--------  class TMMCArgument  --------

inline TMMCArgument::TMMCArgument()

/**

 * Default constructor

 * Initialises the argument to zero.

 */

	{}

inline TMMCArgument::TMMCArgument(const TUint32& aData)

 : iData(aData)

/**

 * Constructs a TMMCArgument with a 32-bit parameter.

 * @param aData The 32-bit parameter.

 */

	{}

inline TMMCArgument::TMMCArgument(TRCA anRCA) : iData(TUint(anRCA)<<16)

/**

 * Constructs a TMMCArgument with a Relative Card Address (RCA).

 * @param anRCA The RCA.

 */

	{}

inline TMMCArgument::TMMCArgument(TDSR aDSR) : iData(TUint(aDSR)<<16)

/**

 * Constructs a TMMCArgument with a Driver Stage Register (DSR).

 * @param aDSR The DSR.

 */

	{}

inline TMMCArgument::operator TUint32() const 

/**

 * Converts the TMMCArgument to it's raw 32-bit representation.

 * @return Raw 32-bit argument data

 */

	{return(iData);}

inline void TMMCArgument::SetRCA(TRCA anRCA)	

/**

 * Sets the Relative Card Address

 * @param anRCA The RCA.

 */

	{iData=(iData&0xFFFF)|(TUint(anRCA)<<16);}

//	--------  class TRCA  --------

inline TRCA::TRCA(TUint16 aData) : iData(aData)

/**

 * Constructs a TRCA with a 16-bit RCA.

 * @param aData The 16-bit RCA.

 */

	{}

inline TRCA::TRCA(TInt aData) : iData(static_cast<TUint16>(aData))

/**

 * Constructs a TRCA with a parameter of type TInt.

 * @param aData The TInt parameter.

 */

	{}

inline TRCA::TRCA(TMMCArgument aData)

/**

 * Constructs a TRCA with a TMMCArgument containing a RCA.

 * @param aData The argument containing the RCA.

 */

	{iData=(TUint16)((TUint32(aData)>>16)&0xFFFF);}

inline TRCA::operator TUint16() const

/**

 * Converts the TRCA to it's raw 16-bit representation.

 * @return Raw 16-bit RCA

 */

	{return(iData);}

//	--------  class TDSR  --------

inline TDSR::TDSR()

/**

 * Default constructor.

 * Initialises the DRS to zero

 */

	{}

inline TDSR::TDSR(TUint16 aData) : iData(aData)

/**

 * Constructs a TDSR with a 16-bit DSR.

 * @param aData The 16-bit DSR.

 */

	{}

inline TDSR::operator TUint16() const 

/**

 * Converts the TDSR to it's raw 16-bit representation.

 * @return Raw 16-bit DSR

 */

	{return(iData);}

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

inline TBool TMMCard::IsHighCapacity() const	{ return (iFlags & KMMCardIsHighCapacity) != 0; }

inline TBool TMMCard::IsPresent() const

//

// If the card is present, its index shows the card number + 1

//

	{return( iIndex != 0 );}

inline TInt TMMCard::Number() const						{return( iIndex - 1 );}

inline TMMCMediaTypeEnum TMMCard::MediaType() const		{return(iCSD.MediaType());}

inline const TCID& TMMCard::CID() const					{return(iCID);}

inline const TCSD& TMMCard::CSD() const					{return(iCSD);}

inline const TExtendedCSD& TMMCard::ExtendedCSD() const	{return(iExtendedCSD);}

inline TRCA TMMCard::RCA() const						{return(iRCA);}

inline TBool TMMCard::HasPassword() const				{return(iFlags&KMMCardHasPassword);}

inline TBool TMMCard::IsWriteProtected() const			{return(iFlags&KMMCardIsWriteProtected);}

inline TUint TMMCard::DeviceSize() const

	{

	TInt64 capacity = DeviceSize64();

	return(capacity > KMaxTInt ? KMaxTInt : I64LOW(capacity));

	}

/** 

Gets the bus width setting for this card.

Note returned value may differ from current host controller bus width setting. 

returns 1, 4 or 8

*/

inline TInt TMMCard::BusWidth() const					

	{return iBusWidth;}

/**

Sets the bus width setting for this card. 

Note this buswidth will not be applied to the host controller and is only used for recording.

@param aBusWidth the bus width to set - valid values are 1, 4 or 8

*/

inline void TMMCard::SetBusWidth(TInt aBusWidth)

	{iBusWidth=aBusWidth;}

inline void TMMCard::SetHighSpeedClock(TUint32 aHighSpeedClock)

	{iHighSpeedClock = aHighSpeedClock;}

inline TUint32 TMMCard::HighSpeedClock() const

	{return iHighSpeedClock;}

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

inline TMMCardArray::TMMCardArray(DMMCStack* anOwningStack) 

	{iOwningStack=anOwningStack;}

inline TUint TMMCardArray::NewCardCount()

	{return(iNewCardsCount);}

inline TInt TMMCardArray::CardsPresent()

	{return(iCardsPresent);}

inline TMMCard* TMMCardArray::NewCardP(TUint aNewCardNumber)

	{return(iNewCards[aNewCardNumber]);}

inline TMMCard* TMMCardArray::CardP(TUint aCardNumber)

	{return(iCards[aCardNumber]);}

inline TMMCard& TMMCardArray::NewCard(TUint aCardNumber)

	{return *iNewCards[aCardNumber];}

inline TMMCard& TMMCardArray::Card(TUint aCardNumber)

	{return *iCards[aCardNumber];}

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

inline TBool TMMCCommandDesc::IsBlockCmd() const

	{ return ((iFlags & KMMCCmdFlagBlockAddress) != 0); }

inline TUint32 TMMCCommandDesc::NumBlocks() const

	{ return iTotalLength / BlockLength(); }

inline TInt64 TMMCCommandDesc::Arg64() const	

	{ return IsBlockCmd()? ((TInt64)(TUint32)iArgument) << KMMCardHighCapBlockSizeLog2 : (TInt64)(TUint32)iArgument; }

inline TBool TMMCCommandDesc::IsDoubleBuffered() const

	{ return ((iFlags & KMMCCmdFlagDoubleBuffer) != 0); }

inline TBool TMMCCommandDesc::IsPhysicalAddress() const

	{ return ((iFlags & KMMCCmdFlagPhysAddr) != 0); }

/**

Returns the buffer length in bytes. If the current request is double-buffered,

this returns the amount of data available in the currently active buffer.

If the command is not double-buffered, the total amount of data to be transferred is returned.

@return Buffer length in bytes

*/

inline TUint32 TMMCCommandDesc::BufferLength() const

	{ return (IsDoubleBuffered() ? (iBlockLength >> 16) << KMMCardHighCapBlockSizeLog2 : iTotalLength); }

inline TUint32 TMMCCommandDesc::BlockLength() const

	{ return (IsDoubleBuffered() ? (iBlockLength & 0x0000FFFF) : iBlockLength); }

//	--------  class TMMCStackConfig  --------

inline TMMCStackConfig::TMMCStackConfig() : iUpdateMask(0), iClientMask(0)

/**

 * Constructor for a TMMCStackConfig object.

 */

	{}

inline void TMMCStackConfig::SetMode(TUint32 aMask)

/**

 * Enable a single mode or a set of modes.

 * Enabled modes should be considered by the Controller as effective. However, client mode 

 * settings may be overridden by master settings.

 * @param aMask The mode(s) to be set.

 */

	{iModes |= aMask; iUpdateMask |= aMask;}

inline void TMMCStackConfig::RemoveMode(TUint32 aMask)

/**

 * Disable a single mode or a set of modes.

 * Disabled modes should be considered by the Controller as not in effect. However, client mode

 * settings may be overridden by master settings.

 * @param aMask The mode(s) to be removed.

 */

	{iModes &= ~aMask; iUpdateMask |= aMask;}

inline void TMMCStackConfig::UseDefault(TUint32 aMask)

/**

 * Restore a single mode or a set of modes to the default setting setting for the platform.

 * @param aMask The mode(s) to be restored.

 */

	{iUpdateMask &= ~aMask; iClientMask &= ~aMask;}

inline void TMMCStackConfig::SetPollAttempts(TUint aData)

/** 

 * Set the number of attempts the Controller is allowed to make to recover on busy timeout during writes to the card.

 * The default setting for this is KMMCMaxPollAttempts (i.e. 5).

 * @param aData The number of attempts to make to recover on busy timeout during write

 */

	{iPollAttempts=aData; iClientMask |= KMMCModeClientPollAttempts; }

inline void TMMCStackConfig::SetOpCondBusyTimeout(TUint16 aData)

/**

 * Set the number of attempts the Controller is allowed to make to recover on busy timeout

 * while waiting for a card which is slow to power up during stack initialisation. The default setting 

 * for this is KMMCMaxOpCondBusyTimeout (i.e. 100).

 * @param aData The number of attempts to make to recover on busy timeout during power up

*/

	{iOpCondBusyTimeout=aData; iClientMask |= KMMCModeClientiOpCondBusyTimeout; }

inline TInt TMMCStackConfig::OpCondBusyTimeout()

/**

 * Return the number of attempts the Controller is allowed to make to recover on busy timeout

 * while waiting for a card which is slow to power up during stack initialisation.

 * @return The number of attempts to make to recover on busy timeout

*/

	{return((TInt)iOpCondBusyTimeout);}

inline void TMMCStackConfig::SetTimeOutRetries(TUint aData)

/** 

 * Set the number of auto reties the Controller is allowed to make on command response time-out or data 

 * block receive timeout situations. The default setting for this is KMMCMaxTimeOutRetries (i.e. 1).

 * @param aData The number of auto reties to make on command response time-out or data block receive timeout condition.

 */

	{iTimeOutRetries=aData; iClientMask |= KMMCModeClientTimeOutRetries; }

inline void TMMCStackConfig::SetCRCRetries(TUint aData)

/** 

 * Set the number of auto reties the Controller is allowed to make on CRC error situations. 

 * The default setting for this is KMMCMaxCRCRetries (i.e. 1).

 * @param aData The number of auto reties to make on a CRC error condition.

 */

	{iCRCRetries=aData; iClientMask |= KMMCModeClientCRCRetries; }

inline void TMMCStackConfig::SetBusClockInKhz(TUint aData)

/** 

 * Set the bus clock speed in kilohertz.

 * The default master setting for this depends on the platform (set in DMMCStack::SetBusConfigDefaults).

 * @param aData The bus clock speed in kilohertz

 */

	{iBusConfig.iBusClock=aData; iClientMask |= KMMCModeClientBusClock; }

inline void TMMCStackConfig::SetTicksClockIn(TUint aData)

/** 

 * Set the number of clock ticks in the ClockIn phase to be used. 

 * The default master setting for this depends on the platform (set in DMMCStack::SetBusConfigDefaults).

 * @param aData The number of clock ticks in the ClockIn phase

 */

	{iBusConfig.iClockIn=aData; iClientMask |= KMMCModeClientClockIn; }

inline void TMMCStackConfig::SetTicksClockOut(TUint aData)

/** 

 * Set the number of clock ticks in the ClockOut phase to be used. 

 * The default master setting for this depends on the platform (set in DMMCStack::SetBusConfigDefaults).

 * @param aData The number of clock ticks in the ClockOut phase

 */

	{iBusConfig.iClockOut=aData; iClientMask |= KMMCModeClientClockOut; }