/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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 "T_MmcSDStackDriverData.h"

#include "MmcTestUtils.h"

//MMCSD Commands index

/*@{*/

_LIT(KCmdStackAdjustPartialRead, 						"AdjustPartialRead");

_LIT(KCmdStackAllocSession, 							"AllocSession");

_LIT(KCmdStackBufferInfo, 								"BufferInfo");

_LIT(KCmdStackDemandPagingInfo, 						"DemandPagingInfo");

_LIT(KCmdStackEffectiveModes, 							"EffectiveModes");

_LIT(KCmdStackAlterEffectiveModes, 						"AlterEffectiveModes");

_LIT(KCmdStackGetBufferInfo, 							"GetBufferInfo");

_LIT(KCmdStackHasCardsPresent, 							"HasCardsPresent");

_LIT(KCmdStackHasSessionsQueued, 						"HasSessionsQueued");

_LIT(KCmdStackInit, 									"Init");

_LIT(KCmdStackInitStackInProgress, 						"InitStackInProgress");

_LIT(KCmdStackMMCSocket, 								"MMCSocket");

_LIT(KCmdStackMachineInfo, 								"MachineInfo");

_LIT(KCmdStackMaxCardsInStack, 							"MaxCardsInStack");

_LIT(KCmdStackReadPasswordStore, 						"ReadPasswordStore");

_LIT(KCmdStackWritePasswordStore, 						"WritePasswordStore");

_LIT(KCmdStackProgramPeriodInMs, 						"ProgramPeriodMs");

_LIT(KCmdStackStop, 									"Stop");

_LIT(KCmdStackReportPowerUp, 							"ReportPowerUp");

_LIT(KCmdStackReportPowerDown, 							"ReportPowerDown");

_LIT(KCmdStackCardP, 									"CardP");

// ini file tags

_LIT(KPrdStart, 										"prdstart");

_LIT(KPrdEnd, 											"prdend");

_LIT(KPrdExpectedStart, 								"expectedprdstart");

_LIT(KPrdExpectedEnd, 									"expectedprdend");

_LIT(KExpectedBufLen, 									"expectedBuflen");

_LIT(KExpectedMinorBufLen, 								"expectedMinorBuflen");

_LIT(KExpectedMaxCardsInStack, 							"maxcards");

_LIT(KProgramPeriodMs, 									"programperiodms");

_LIT(KInProgress, 										"inprogress");

_LIT(KSessionsQueued, 									"sessionsqueued");

_LIT(KCardsPresent, 									"cardspresent");

_LIT(KExpectedTotalSockets, 							"expectedtotalsockets");

_LIT(KExpectedTotalMediaChanges, 						"expectedtotalmediachanges");

_LIT(KExpectedTotalPrimarySupplies, 					"expectedtotalprimarysupplies");

_LIT(KExpectedSPIMode, 									"expectedspimode");

_LIT(KExpectedBaseBusNumber, 							"expectedbasebusnumber");

_LIT(KHasFlagSupportsSPIMode, 							"hasflagsupportsspimode");

_LIT(KHasFlagSupportsDoubleBuffering, 					"hasflagsupportsdoublebuffering");

_LIT(KHasFlagSupportsR7, 								"hasflagsupportsr7");

_LIT(KHasFlagDma8BitAddressing, 						"hasflagdma8bitaddressing");

_LIT(KHasFlagDma16BitAddressing, 						"hasflagdma16bitaddressing");

_LIT(KHasFlagDma32BitAddressing, 						"hasflagdma32bitaddressing");

_LIT(KHasFlagDma64BitAddressing, 						"hasflagdma64bitaddressing");

_LIT(KHasFlagSupportsDMA, 								"hasflagsupportsdma");

_LIT(KHasFlagMaxTransferLength_256K, 					"hasflagmaxtransferlength256k");

_LIT(KHasFlagMaxTransferLength_512K, 					"hasflagmaxtransferlength512k");

_LIT(KHasFlagMaxTransferLength_1M, 						"hasflagmaxtransferlength1m");

_LIT(KHasFlagMaxTransferLength_2M, 						"hasflagmaxtransferlength2m");

_LIT(KHasFlagMaxTransferLength_4M, 						"hasflagmaxtransferlength4m");

_LIT(KHasFlagMaxTransferLength_8M, 						"hasflagmaxtransferlength8m");

_LIT(KHasFlagMaxTransferLength_16M, 					"hasflagmaxtransferlength16m");

_LIT(KPassword, 										"password");

_LIT(KIsNull, 											"isnull");

_LIT(KEffectiveModes, 									"effectivemodes");

_LIT(KEffectiveModesFunctionId, 						"emfunctionid");

_LIT(KEffectiveModesData, 								"emdata");

_LIT(KDriveCount, 										"drivecount");

_LIT(KNumPages, 										"numpages");

_LIT(KPagingType, 										"pagingtype");

_LIT(KWriteProtected, 									"writeprotected");

_LIT(KCardNumber, 										"cardnumber");

_LIT(KSocketWrapperName,								"socketwrappername");

// TEffectiveModesFunctionId enum strings

_LIT(KEffectiveModesRemoveMode, 						"EEffectiveModesRemoveMode");

_LIT(KEffectiveModesSetBusClockInKhz, 					"EEffectiveModesSetBusClockInKhz");

_LIT(KEffectiveModesSetBusyTimeOutInMcs, 				"EEffectiveModesSetBusyTimeOutInMcs");

_LIT(KEffectiveModesSetCRCRetries, 						"EEffectiveModesSetCRCRetries");

_LIT(KEffectiveModesSetDataTimeOutInMcs, 				"EEffectiveModesSetDataTimeOutInMcs");

_LIT(KEffectiveModesSetMode, 							"EEffectiveModesSetMode");

_LIT(KEffectiveModesSetOpCondBusyTimeout, 				"EEffectiveModesSetOpCondBusyTimeout");

_LIT(KEffectiveModesSetPollAttempts, 					"EEffectiveModesSetPollAttempts");

_LIT(KEffectiveModesSetResponseTimeOutInTicks,			"EEffectiveModesSetResponseTimeOutInTicks");

_LIT(KEffectiveModesSetTicksClockIn, 					"EEffectiveModesSetTicksClockIn");

_LIT(KEffectiveModesSetTicksClockOut, 					"EEffectiveModesSetTicksClockOut");

_LIT(KEffectiveModesSetTimeOutRetries, 					"EEffectiveModesSetTimeOutRetries");

_LIT(KInvalidEffectiveModesFunctionId,					"EInvalidEffectiveModesFunctionId");	

/**	Enum as a descriptor  				Enum integar value													

 *	In this case these enums represent TEffectiveModesFunctionId

 *                                                                             

 * 																											      							

 */																														

const CDataWrapperBase::TEnumEntryTable	CT_MMCSDStackDriverData::iEnumEffectiveModesFunctionIdTable [] =

	{

//	Enum as a descriptor								Enum

	KEffectiveModesRemoveMode,							RMMCSDTestControllerInterface::EStackEffectiveModesRemoveMode,

	KEffectiveModesSetBusClockInKhz,					RMMCSDTestControllerInterface::EStackEffectiveModesSetBusClockInKhz,

	KEffectiveModesSetBusyTimeOutInMcs,					RMMCSDTestControllerInterface::EStackEffectiveModesSetBusyTimeOutInMcs,

	KEffectiveModesSetCRCRetries,						RMMCSDTestControllerInterface::EStackEffectiveModesSetCRCRetries,

	KEffectiveModesSetDataTimeOutInMcs,					RMMCSDTestControllerInterface::EStackEffectiveModesSetDataTimeOutInMcs,

	KEffectiveModesSetMode,								RMMCSDTestControllerInterface::EStackEffectiveModesSetMode,

	KEffectiveModesSetOpCondBusyTimeout,				RMMCSDTestControllerInterface::EStackEffectiveModesSetOpCondBusyTimeout,

	KEffectiveModesSetPollAttempts,						RMMCSDTestControllerInterface::EStackEffectiveModesSetPollAttempts,

	KEffectiveModesSetResponseTimeOutInTicks,			RMMCSDTestControllerInterface::EStackEffectiveModesSetResponseTimeOutInTicks,

	KEffectiveModesSetTicksClockIn,						RMMCSDTestControllerInterface::EStackEffectiveModesSetTicksClockIn,

	KEffectiveModesSetTicksClockOut,					RMMCSDTestControllerInterface::EStackEffectiveModesSetTicksClockOut,

	KEffectiveModesSetTimeOutRetries,					RMMCSDTestControllerInterface::EStackEffectiveModesSetTimeOutRetries,

	KInvalidEffectiveModesFunctionId,					-1

	};

/*@}*/

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

/**

 * static Construction

 *

 *

 * @return					A pointer to T_MMCSDStackDriverData

 *

 * @leave					System wide error

 */

CT_MMCSDStackDriverData* CT_MMCSDStackDriverData::NewL()

	{

	CT_MMCSDStackDriverData* ret = new (ELeave) CT_MMCSDStackDriverData();

	CleanupStack::PushL(ret);

	ret->ConstructL();

	CleanupStack::Pop(ret);

	return ret;

	}

/**

 * Constructor

 *

 * @return					N/A

 *

 * @leave					N/A

 */

CT_MMCSDStackDriverData::CT_MMCSDStackDriverData()

: CT_MmcSDDriverData()

	{

	}

/**

 * 2nd Phase constructor

 *

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDStackDriverData::ConstructL()

	{

	CT_MmcSDDriverData::ConstructL();

	}

/**

 * Destructor

 *

 * @return					N/A

 *

 * @leave					N/A

 */

CT_MMCSDStackDriverData::~CT_MMCSDStackDriverData()

	{

	}

/**

 * Process a command read from the script file

 *

 * @param aCommand			The command to process

 * @param aSection			The section in the ini containing data for the command

 * @param aAsyncErrorIndex	Command index for async calls to return errors to

 *

 * @return					ETrue if the command is processed

 *

 * @leave					System wide error

 */

TBool CT_MMCSDStackDriverData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

	{

	TBool ret = ETrue;

	if (aCommand == KCmdStackAdjustPartialRead)

		{

		DoCmdAdjustPartialRead(aSection);

		}

	else if (aCommand == KCmdStackAllocSession)

		{

		DoCmdAllocSession();

		}

	else if (aCommand == KCmdStackBufferInfo)

		{

		DoCmdBufferInfo(aSection);

		}

	else if (aCommand == KCmdStackDemandPagingInfo)

		{

		DoCmdDemandPagingInfo(aSection);

		}

	else if (aCommand == KCmdStackEffectiveModes)

		{

		DoCmdEffectiveModes(aSection);

		}

	else if (aCommand == KCmdStackGetBufferInfo)

		{

		DoCmdGetBufferInfo(aSection);

		}

	else if (aCommand == KCmdStackHasCardsPresent)

		{

		DoCmdHasCardsPresent(aSection);

		}

	else if (aCommand == KCmdStackHasSessionsQueued)

		{

		DoCmdHasSessionsQueued(aSection);

		}

	else if (aCommand == KCmdStackInit)

		{

		DoCmdInit();

		}

	else if (aCommand == KCmdStackInitStackInProgress)

		{

		DoCmdInitStackInProgress(aSection);

		}

	else if (aCommand == KCmdStackMMCSocket)

		{

		DoCmdMMCSocketL(aSection);

		}

	else if (aCommand == KCmdStackMachineInfo)

		{

		DoCmdMachineInfo(aSection);

		}

	else if (aCommand == KCmdStackMaxCardsInStack)

		{

		DoCmdMaxCardsInStack(aSection);

		}

	else if (aCommand == KCmdStackReadPasswordStore)

		{

		DoCmdPasswordStore(aSection);

		}

	else if (aCommand == KCmdStackWritePasswordStore)

		{

		DoCmdWritePasswordStore(aSection);

		}

	else if (aCommand == KCmdStackProgramPeriodInMs)

		{

		DoCmdProgramPeriodInMilliSeconds(aSection);

		}

	else if (aCommand == KCmdStackStop)

		{

		DoCmdStop(aSection);

		}

	else if (aCommand == KCmdStackReportPowerUp)

		{

		DoCmdReportPowerUp(aSection);

		}

	else if (aCommand == KCmdStackReportPowerDown)

		{

		DoCmdReportPowerDown(aSection);

		}

	else if (aCommand == KCmdStackCardP)

		{

		DoCmdCardP(aSection);

		}

	else if (aCommand == KCmdStackAlterEffectiveModes)

		{

		DoCmdAlterEffectiveModes(aSection);

		}

	else

		{

		ret = CT_MmcSDDriverData::DoCommandL(aCommand, aSection, aAsyncErrorIndex);

		}

	return ret;

	}

/**

 * Process command that will result in call to DMMCStack::AdjustPartial kernel side

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void  CT_MMCSDStackDriverData::DoCmdAdjustPartialRead(const TDesC& aSection)

	{

	TPartialReadData prd;

	prd.iStart = 0;

	prd.iEnd = 0;

	if(! GetUintFromConfig(aSection, KPrdStart(), prd.iStart) )

		{

		ERR_PRINTF1(_L("Failed to get prdstart from ini file"));

		SetBlockResult(EFail);

		}

	if(!GetUintFromConfig(aSection, KPrdEnd(), prd.iEnd))

		{

		ERR_PRINTF1(_L("Failed to get prdend from ini file"));

		SetBlockResult(EFail);		

		}

	INFO_PRINTF3(_L("Calling MMCStack::AdjustPartialRead(start=%d, end=%d)"), prd.iStart, prd.iEnd);

	TInt err = iMmcSDController->StackAdjustPartialRead(prd);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("MMCStack::AdjustPartialRead() Error %d"), err);

		SetError(err);

		}

	else

		{

		INFO_PRINTF3(_L("MMCStack::AdjustPartialRead() = %d, %d"), prd.iPhysStart, prd.iPhysEnd);

		TUint expectedStart;

		if( !GetUintFromConfig(aSection, KPrdExpectedStart(), expectedStart) )

			{

			ERR_PRINTF1(_L("Failed to get KPrdExpectedStart from ini file"));

			SetBlockResult(EFail);

			}

		else if(prd.iPhysStart != expectedStart )

			{

			ERR_PRINTF3(_L("phys start(%d) != expectedStart(%d)"), prd.iPhysStart, expectedStart);

			SetBlockResult(EFail);

			}

		TUint expectedEnd;

		if( !GetUintFromConfig(aSection, KPrdExpectedEnd(), expectedEnd) )

			{

			ERR_PRINTF1(_L("Failed to get KPrdExpectedEnd from ini file"));

			SetBlockResult(EFail);			

			}

		else if(prd.iPhysEnd != expectedEnd )

			{

			ERR_PRINTF3(_L("MMCStack::AdjustPartialRead phys end(%d) != expected end(%d)"), prd.iPhysEnd, expectedEnd);

			SetBlockResult(EFail);

			}

		}

	}

/**

 * Process command that will result in call to DMMCStack::AllocSession kernel side

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void  CT_MMCSDStackDriverData::DoCmdAllocSession()

	{

	INFO_PRINTF1(_L("Calling MMCStack::AllocSession()"));

	iMmcSDController->StackAllocSession();

	}

/**

 * Process command that will result in call to DMMCStack::BufferInfo kernel side

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDStackDriverData::DoCmdBufferInfo(const TDesC& aSection)

	{

	TBufferInfo bufferInfo;

	INFO_PRINTF1(_L("Calling MMCStack::BufferInfo()"));

	TInt err = iMmcSDController->StackBufferInfo(bufferInfo);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("MMCStack::BufferInfo() Error %d"), err);

		SetError(err);

		}

	else

		{

		INFO_PRINTF4(_L("BufferInfo() iBuf(%x) iBufLen(%d) iMinorBufLen(%d)"),

				bufferInfo.iBuf, bufferInfo.iBufLen, bufferInfo.iMinorBufLen);

		// check the expected length

		TInt expectedBufLen;

		if( ! GetIntFromConfig(aSection, KExpectedBufLen(), expectedBufLen ))

			{

			ERR_PRINTF1(_L("Failed to get KExpectedBufLen from ini file"));

			SetBlockResult(EFail);

			}

		else if(bufferInfo.iBufLen != expectedBufLen )

			{

			ERR_PRINTF3(_L("bufferInfo.iBufLen (%d) != expectedBufLen(%d)"),

					bufferInfo.iBufLen , expectedBufLen);

			SetBlockResult(EFail);

			}

		// check the expected minor length

		TInt expectedMinorBufLen;

		if( !GetIntFromConfig(aSection, KExpectedMinorBufLen(), expectedMinorBufLen ))

			{

			ERR_PRINTF1(_L("Failed to get KExpectedMinorBufLen from ini file"));

			SetBlockResult(EFail);

			}

		else if(bufferInfo.iMinorBufLen != expectedMinorBufLen )

			{

			ERR_PRINTF3(_L("bufferInfo.iMinorBufLen (%d) != expectedMinorBufLen(%d)"),

					bufferInfo.iMinorBufLen , expectedMinorBufLen);

			SetBlockResult(EFail);

			}

		}

	}

/**

 * Process command that will result in call to DMMCStack::GetBufferInfo kernel side

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDStackDriverData::DoCmdGetBufferInfo(const TDesC& aSection)

	{

	TBufferInfo bufferInfo;

	INFO_PRINTF1(_L("Calling MMCStack::GetBufferInfo()"));

	TInt err = iMmcSDController->StackGetBufferInfo(bufferInfo);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("MMCStack::GetBufferInfo() Error %d"), err);

		SetError(err);

		}

	else

		{

		INFO_PRINTF3(_L("GetBufferInfo() iBuf(%x) iBufLen(%d)"),

				bufferInfo.iBuf, bufferInfo.iBufLen);

		// check the expected length

		TInt expectedBufLen;

		if( !GetIntFromConfig(aSection, KExpectedBufLen(), expectedBufLen ))

			{

			ERR_PRINTF1(_L("Failed to get KExpectedBufLen from ini file"));

			SetBlockResult(EFail);

			}

		else if(bufferInfo.iBufLen != expectedBufLen )

			{

			ERR_PRINTF3(_L("bufferInfo.iBufLen (%d) != expectedBufLen(%d)"),

					bufferInfo.iBufLen , expectedBufLen);

			SetBlockResult(EFail);

			}

		}

	}

/**

 * Process command that will result in call to DMMCStack::DemandPagingInfo kernel side

 *

 * @param aSection			The section in the ini containing data for the command

 *

 * @return					void

 *

 * @leave					System wide error

 */

void CT_MMCSDStackDriverData::DoCmdDemandPagingInfo(const TDesC& aSection)

	{

	TTCDemandPagingInfo info;

	INFO_PRINTF1(_L("Calling MMCStack::DemandPagingInfo()"));

	TInt err = iMmcSDController->StackDemandPagingInfo(info);

	if(err != KErrNone)

		{

		ERR_PRINTF2(_L("MMCStack::DemandPagingInfo() Error %d"), err);

		SetError(err);

		}

	else

		{

		INFO_PRINTF4(_L("info.iPagingDriveList(%x) info.iDriveCount(%d) info.iPagingType(%d)"),

				info.iPagingDriveList, info.iDriveCount, info.iPagingType);

		INFO_PRINTF4(_L("info.iReadShift(%d) info.iNumPages(%d) info.iWriteProtected(%d)"),

				info.iReadShift, info.iNumPages, info.iWriteProtected);

		// read expected values here		

		TInt driveCount;

		if(!GetIntFromConfig(aSection, KDriveCount(), driveCount))

			{

			ERR_PRINTF1(_L("Failed to read KDriveCount from ini file"));

			SetBlockResult(EFail);

			}

		else

			{

			if(driveCount != info.iDriveCount)

				{

				ERR_PRINTF3(_L("drive counts do not match actual(%d), expected(%d)"), info.iDriveCount, driveCount);

				SetBlockResult(EFail);				

				}	

			}

		TUint pagingType;

		if(!GetUintFromConfig(aSection, KPagingType(), pagingType))

			{

			ERR_PRINTF1(_L("Failed to read pagingType from ini file"));

			SetBlockResult(EFail);

			}

		else

			{

			if(pagingType != info.iPagingType)

				{

				ERR_PRINTF3(_L("pagingType do not match actual(%d), expected(%d)"), info.iPagingType, pagingType);

				SetBlockResult(EFail);				

				}	

			}