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

#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));

	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.

 */

	{

	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.

 */

	{

	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.

 */

	{

	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.

 */

	{

	// 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).

		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;

	}

TUint TMMCard::MaxTranSpeedInKilohertz() const

/**

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

 * @return Speed, in Kilohertz

 */

	{

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

 */

	{

	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));

		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));

			}

		}

	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.

 */

	{

	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));

		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));

			}

		}