/*
* 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);
}
}
TUint numPages;
if(!GetUintFromConfig(aSection, KNumPages(), numPages))
{
ERR_PRINTF1(_L("Failed to read num pages from ini file"));
SetBlockResult(EFail);
}
else
{
if(numPages != info.iNumPages)
{
ERR_PRINTF3(_L("numPages do not match actual(%d), expected(%d)"), info.iNumPages, numPages);
SetBlockResult(EFail);
}
}
TBool writeProtected;
if(!GetBoolFromConfig(aSection, KWriteProtected(), writeProtected))
{
ERR_PRINTF1(_L("Failed to read writeProtected from ini file"));
SetBlockResult(EFail);
}
else
{
if(writeProtected != info.iWriteProtected)
{
ERR_PRINTF3(_L("writeProtected do not match actual(%d), expected(%d)"), info.iWriteProtected, writeProtected);
SetBlockResult(EFail);
}
}
}
}
/**
* Process command that will result in call to DMMCStack::EffectiveModes kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdEffectiveModes(const TDesC& aSection)
{
INFO_PRINTF1(_L("Calling MMCStack::EffectiveModes()"));
TUint32 actualModes;
TInt err = iMmcSDController->StackEffectiveModes(actualModes);
if (err != KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::EffectiveModes() Error (%d)"), err);
SetError(err);
}
else
{
INFO_PRINTF3(_L("DMMCStack::EffectiveModes() modes(0x%x / %d)"), actualModes, actualModes);
TInt expectedModes;
if(GetHexFromConfig(aSection, KEffectiveModes(), expectedModes))
{
if(((TUint32)expectedModes) != actualModes)
{
ERR_PRINTF5(_L("actual (%d)(%x) and expected(%d)(%x) effectiveModes do not match"), actualModes, actualModes, expectedModes, expectedModes);
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF1(_L("DMMCStack::EffectiveModes() Could not read expectedModes from ini file"));
SetError(err);
}
}
}
/**
* Process command that will result in an update of Effective Modes variable on kernel side
* for a call to DMMCStack::EffectiveModes
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdAlterEffectiveModes(const TDesC& aSection)
{
TInt funcId;
TUint data;
// read funtion ID from section
if (!GetEnumFromConfig(aSection, KEffectiveModesFunctionId(), iEnumEffectiveModesFunctionIdTable, funcId))
{
ERR_PRINTF1(_L("Failed to read Function ID DoCmdEffectiveModes"));
SetBlockResult(EFail);
}
// read data param from section - all params are 32 bit or less
else if (!GetUintFromConfig(aSection, KEffectiveModesData(), data))
{
ERR_PRINTF2(_L("Failed to read DATA DoCmdEffectiveModes funcId(%d)"), funcId);
SetBlockResult(EFail);
}
else
{
INFO_PRINTF3( _L("Calling DoCmdEffectiveModes funcid(%d) data(%u)"), funcId, data);
TInt err = iMmcSDController->StackAlterEffectiveModes((RMMCSDTestControllerInterface::TEffectiveModesFunctionId) funcId, (TAny*)data);
if (err != KErrNone)
{
ERR_PRINTF3(_L("DoCmdEffectiveModes funcid(%d) Error(%d"), funcId, err);
SetError(err);
}
}
}
/**
* Process command that will result in call to DMMCStack::HasCardsPresent kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdHasCardsPresent(const TDesC& aSection)
{
INFO_PRINTF1( _L("CT_MMCSDStackDriverData:::DoCmdHasCardsPresent called"));
TBool actualCardspresent;
TInt err = iMmcSDController->StackHasCardsPresent(actualCardspresent);
if (err != KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::DoCmdHasCardsPresent() Error (%d)"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("DMMCStack::DoCmdHasCardsPresent() actual cards present (%d)"), actualCardspresent);
TBool expectedCardsPresent;
if(!GetBoolFromConfig(aSection, KCardsPresent(), expectedCardsPresent))
{
ERR_PRINTF1(_L("Failed to get KCardsPresent from ini file"));
SetBlockResult(EFail);
}
else if(actualCardspresent != expectedCardsPresent)
{
ERR_PRINTF3(_L("actual (%d) and expected(%d) cards present do not match"), actualCardspresent, expectedCardsPresent);
SetBlockResult(EFail);
}
}
}
/**
* Process command that will result in call to DMMCStack::HasSessionsQueued kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdHasSessionsQueued(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdHasSessionsQueued called"));
TBool actualSessionsQueued;
TInt err = iMmcSDController->StackHasSessionsQueued(actualSessionsQueued);
if (err != KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::DoCmdHasSessionsQueued() Error (%d)"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("DMMCStack::DoCmdHasSessionsQueued() actual sessions queued (%d)"), actualSessionsQueued);
TBool expectedInProgress;
if(!GetBoolFromConfig(aSection, KSessionsQueued(), expectedInProgress))
{
ERR_PRINTF1(_L("Failed to get KSessionsQueued from ini file"));
SetBlockResult(EFail);
}
else if(actualSessionsQueued != expectedInProgress)
{
ERR_PRINTF3(_L("actual (%d) and expected(%d) sessions queued do not match"), actualSessionsQueued, expectedInProgress);
SetBlockResult(EFail);
}
}
}
/**
* Process command that will result in call to DMMCStack::InitStackInProgress kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdInitStackInProgress(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdInitStackInProgress called"));
TBool actualInProgress;
TInt err = iMmcSDController->StackInitStackInProgress(actualInProgress);
if (err != KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::InitStackInProgress() Error (%d)"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("DMMCStack::InitStackInProgress() actualInProgress(%d)"), actualInProgress);
TBool expectedInProgress;
if(!GetBoolFromConfig(aSection, KInProgress(), expectedInProgress))
{
ERR_PRINTF1(_L("Failed to get KInProgress from ini file"));
SetBlockResult(EFail);
}
else if(actualInProgress != expectedInProgress)
{
ERR_PRINTF3(_L("actual (%d) and expected(%d) in progress do not match"), actualInProgress, expectedInProgress);
SetBlockResult(EFail);
}
}
}
/**
* Process command that will result in call to DMMCStack::MMCSocket kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdMMCSocketL(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdMMCSocket called"));
// can't use DMMCSocket type on user side
TAny* socketPtr= NULL;
TInt err = iMmcSDController->StackMMCSocket(&socketPtr);
if (err!=KErrNone)
{
ERR_PRINTF2(_L("MMCStack::Socket() Error %d"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("MMCStack::Socket(): ptr=%x"), socketPtr);
TBool expectedIsNull = EFalse;
if(!GetBoolFromConfig(aSection, KIsNull(), expectedIsNull))
{
ERR_PRINTF1(_L("Failed to get isnull from ini file"));
SetBlockResult(EFail);
}
if (expectedIsNull)
{
if (socketPtr != NULL)
{
ERR_PRINTF1(_L("Socket ptr is not NULL"));
SetBlockResult(EFail);
}
}
else
{
if (!socketPtr)
{
ERR_PRINTF1(_L("Socket ptr is NULL"));
SetBlockResult(EFail);
}
else
{
TPtrC socketWrapperName;
if( GetStringFromConfig(aSection, KSocketWrapperName(), socketWrapperName) )
{
TAny* expectedSocketPtr = GetDataObjectL(socketWrapperName);
INFO_PRINTF2(_L("expectedSocketPtr = %x"), expectedSocketPtr);
if( expectedSocketPtr == NULL )
{
ERR_PRINTF1(_L("MMCStack::Socket(): expectedSocketPtr is NULL"));
SetBlockResult(EFail);
}
else if( socketPtr != expectedSocketPtr )
{
ERR_PRINTF3(_L("socketPtr(%x) != expectedSocketPtr(%x)"), socketPtr, expectedSocketPtr);
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF1(_L("MMCStack::Socket(): Error in Socket Wrapper Name from INI file"));
SetBlockResult(EFail);
}
}
}
}
}
/**
* Process command that will result in call to DMMCStack::MachineInfo kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdMachineInfo(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdMachineInfo called XXX"));
TMachineInfo machineInfo;
TInt err = iMmcSDController->StackMachineInfo(machineInfo);
if (err !=KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::MachineInfo() Error (%d)"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("DMMCStack::MachineInfo(): iTotalSockets=%d"), machineInfo.iTotalSockets);
INFO_PRINTF2(_L("DMMCStack::MachineInfo(): iTotalMediaChanges=%d"), machineInfo.iTotalMediaChanges);
INFO_PRINTF2(_L("DMMCStack::MachineInfo(): iTotalPrimarySupplies=%d"), machineInfo.iTotalPrimarySupplies);
INFO_PRINTF2(_L("DMMCStack::MachineInfo(): iSPIMode=%d"), machineInfo.iSPIMode);
INFO_PRINTF2(_L("DMMCStack::MachineInfo(): iBaseBusNumber=%d"), machineInfo.iBaseBusNumber);
if (machineInfo.iSupportsSPIMode)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag ESupportsSPIMode"));
}
if (machineInfo.iSupportsDoubleBuffering)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag ESupportsDoubleBuffering"));
}
if (machineInfo.iSupportsR7)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag ESupportsR7"));
}
if( machineInfo.iDma8BitAddressing )
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EDma8BitAddressing"));
}
if( machineInfo.iDma16BitAddressing )
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EDma16BitAddressing"));
}
if( machineInfo.iDma32BitAddressing )
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EDma32BitAddressing"));
}
if( machineInfo.iDma64BitAddressing )
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EDma64BitAddressing"));
}
if( machineInfo.iSupportsDMA )
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag ESupportsDMA"));
}
if (machineInfo.iMaxTransferLength_256K)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_256K"));
}
if (machineInfo.iMaxTransferLength_512K)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_512K"));
}
if (machineInfo.iMaxTransferLength_1M)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_1M"));
}
if (machineInfo.iMaxTransferLength_2M)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_2M"));
}
if (machineInfo.iMaxTransferLength_4M)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_4M"));
}
if (machineInfo.iMaxTransferLength_8M)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_8M"));
}
if (machineInfo.iMaxTransferLength_16M)
{
INFO_PRINTF1(_L("DMMCStack::MachineInfo(): Has flag EMaxTransferLength_16M"));
}
TInt expectedInt;
TBool expectedBool;
if( !GetIntFromConfig(aSection, KExpectedTotalSockets(), expectedInt))
{
ERR_PRINTF1(_L("Failed to get KExpectedTotalSockets from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iTotalSockets != expectedInt )
{
ERR_PRINTF3(_L("totalSockets(%d) != expectedTotalSockets(%d)"), machineInfo.iTotalSockets, expectedInt);
SetBlockResult(EFail);
}
if( !GetIntFromConfig(aSection, KExpectedTotalMediaChanges(), expectedInt))
{
ERR_PRINTF1(_L("Failed to get expected total media changes from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iTotalMediaChanges != expectedInt )
{
ERR_PRINTF3(_L("totalMediaChanges(%d) != expectedTotalMediaChanges(%d)"), machineInfo.iTotalMediaChanges, expectedInt);
SetBlockResult(EFail);
}
if( !GetIntFromConfig(aSection, KExpectedTotalPrimarySupplies(), expectedInt))
{
ERR_PRINTF1(_L("Failed to get KExpectedTotalPrimarySupplies from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iTotalPrimarySupplies != expectedInt )
{
ERR_PRINTF3(_L("totalPrimarySupplies(%d) != expectedTotalPrimarySupplies(%d)"), machineInfo.iTotalPrimarySupplies, expectedInt);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KExpectedSPIMode(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KExpectedSPIMode from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iSPIMode != expectedBool )
{
ERR_PRINTF3(_L("SPIMode(%d) != expectedSPIMode(%d)"), machineInfo.iSPIMode, expectedBool);
SetBlockResult(EFail);
}
if( !GetIntFromConfig(aSection, KExpectedBaseBusNumber(), expectedInt))
{
ERR_PRINTF1(_L("Failed to get KExpectedBaseBusNumber from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iBaseBusNumber != expectedInt )
{
ERR_PRINTF3(_L("baseBusNumber(%d) != expectedBaseBusNumber(%d)"), machineInfo.iBaseBusNumber, expectedInt);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagSupportsSPIMode(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagSupportsSPIMode from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iSupportsSPIMode != expectedBool )
{
ERR_PRINTF3(_L("supportsSPIMode(%d) != expectedSupportsSPIMode(%d)"), machineInfo.iSupportsSPIMode, expectedBool);
SetBlockResult(EFail);
}
if(!GetBoolFromConfig(aSection, KHasFlagSupportsDoubleBuffering(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagSupportsDoubleBuffering from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iSupportsDoubleBuffering != expectedBool )
{
ERR_PRINTF3(_L("supportsDoubleBuffering(%d) != expectedSupportsDoubleBuffering(%d)"), machineInfo.iSupportsDoubleBuffering, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagSupportsR7(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagSupportsR7 from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iSupportsR7 != expectedBool )
{
ERR_PRINTF3(_L("supportsR7(%d) != expectedSupportsR7(%d)"), machineInfo.iSupportsR7, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagDma8BitAddressing(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagDma8BitAddressing from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iDma8BitAddressing != expectedBool )
{
ERR_PRINTF3(_L("Dma8BitAddressing(%d) != expectedDma8BitAddressing(%d)"), machineInfo.iDma8BitAddressing, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagDma16BitAddressing(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagDma16BitAddressing from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iDma16BitAddressing != expectedBool )
{
ERR_PRINTF3(_L("Dma16BitAddressing(%d) != expectedDma16BitAddressing(%d)"), machineInfo.iDma16BitAddressing, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagDma32BitAddressing(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagDma32BitAddressing from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iDma32BitAddressing != expectedBool )
{
ERR_PRINTF3(_L("Dma32BitAddressing(%d) != expectedDma32BitAddressing(%d)"), machineInfo.iDma32BitAddressing, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagDma64BitAddressing(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagDma64BitAddressing from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iDma64BitAddressing != expectedBool )
{
ERR_PRINTF3(_L("Dma64BitAddressing(%d) != expectedDma64BitAddressing(%d)"), machineInfo.iDma64BitAddressing, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagSupportsDMA(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagSupportsDMA from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iSupportsDMA != expectedBool )
{
ERR_PRINTF3(_L("SupportsDMA(%d) != expectedSupportsDMA(%d)"), machineInfo.iSupportsDMA, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_256K(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_256K( from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_256K != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_256K(%d) != expectedMaxTransferLength_256K(%d)"), machineInfo.iMaxTransferLength_256K, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_512K(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_512K from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_512K != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_512K(%d) != expectedMaxTransferLength_512K(%d)"), machineInfo.iMaxTransferLength_512K, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_1M(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_1M from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_1M != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_1M(%d) != expectedMaxTransferLength_1M(%d)"), machineInfo.iMaxTransferLength_1M, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_2M(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_2M from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_2M != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_2M(%d) != expectedMaxTransferLength_2M(%d)"), machineInfo.iMaxTransferLength_2M, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_4M(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_4M from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_4M != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_4M(%d) != expectedMaxTransferLength_4M(%d)"), machineInfo.iMaxTransferLength_4M, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_8M(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_8M from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_8M != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_8M(%d) != expectedMaxTransferLength_8M(%d)"), machineInfo.iMaxTransferLength_8M, expectedBool);
SetBlockResult(EFail);
}
if( !GetBoolFromConfig(aSection, KHasFlagMaxTransferLength_16M(), expectedBool))
{
ERR_PRINTF1(_L("Failed to get KHasFlagMaxTransferLength_16M from ini file"));
SetBlockResult(EFail);
}
else if(machineInfo.iMaxTransferLength_16M != expectedBool )
{
ERR_PRINTF3(_L("maxTransferLength_16M(%d) != expectedMaxTransferLength_16M(%d)"), machineInfo.iMaxTransferLength_16M, expectedBool);
SetBlockResult(EFail);
}
}
}
/**
* Process command that will result in call to DMMCStack::MaxCardsInStack kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdMaxCardsInStack(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdMaxCardsInStack called"));
TUint actualMaxCardsInStack;
iMmcSDController->StackMaxCardsInStack(actualMaxCardsInStack);
TUint expectedMaxCardsInStack;
if(!GetUintFromConfig(aSection, KExpectedMaxCardsInStack(), expectedMaxCardsInStack))
{
ERR_PRINTF1(_L("Failed to get KExpectedMaxCardsInStack from ini file"));
SetBlockResult(EFail);
}
else if(actualMaxCardsInStack != expectedMaxCardsInStack)
{
ERR_PRINTF3(_L("MaxCardsInStack actualMaxCardsInStack (%d) != expectedMaxCardsInStack(%d)")
,actualMaxCardsInStack, expectedMaxCardsInStack);
SetBlockResult(EFail);
}
}
/**
* Process command that will result in call to DMMCStack::PasswordStore kernel side
* and retrieve the password in the store
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdPasswordStore(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdPasswordStore called"));
TStackPasswordStoreData pwdStoreData;
TInt err = iMmcSDController->StackReadPasswordStore(pwdStoreData);
if (err != KErrNone)
{
ERR_PRINTF2(_L("MMCStack::DoCmdPasswordStore() Error %d"), err);
SetError(err);
}
else
{
if (!pwdStoreData.iPwdStorePtr)
{
ERR_PRINTF1(_L("MMCStack::DoCmdPasswordStore() retrieved a NULL pointer"));
SetError(err);
}
else
{
INFO_PRINTF2( _L("Password Store ptr (%x)"), pwdStoreData.iPwdStorePtr);
TBuf<KMmcPwdLen> pwd;
pwd.Copy(pwdStoreData.iPassword);
INFO_PRINTF2( _L("PwdStore Password (%S)"), &pwd);
TPtrC tmp;
if (GetStringFromConfig(aSection, KPassword(), tmp))
{
INFO_PRINTF2( _L("Expected password (%S)"), &tmp);
if(tmp != pwd)
{
ERR_PRINTF1( _L("PASSWORD does not match"));
SetBlockResult(EFail);
}
}
else
{
ERR_PRINTF1( _L("failed to read password"));
SetBlockResult(EFail);
}
}
}
}
/**
* Process command that will result in call to DMMCStack::PasswordStore kernel side
* and update the password in the store
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdWritePasswordStore(const TDesC& aSection)
{
INFO_PRINTF1( _L(" CT_MMCSDStackDriverData::DoCmdWritePasswordStore called"));
// read the password to set from ini file
TPtrC tmp;
if (GetStringFromConfig(aSection, KPassword(), tmp))
{
INFO_PRINTF2( _L("Attempting to write password (%S) to password store"), &tmp);
TStackPasswordStoreData pwdStoreData;
pwdStoreData.iPassword.Copy(tmp);
TInt err = iMmcSDController->StackWritePasswordStore(pwdStoreData);
if (err == KErrNone)
{
INFO_PRINTF1(_L("Wrote password ok"));
}
else
{
ERR_PRINTF2( _L("StackWritePasswordStore failed err(%d)"), err);
SetError(err);
}
}
else
{
ERR_PRINTF1( _L("Failed to read PASSWORD to write from ini file"));
SetBlockResult(EFail);
}
}
/**
* Process command that will result in call to DMMCStack::ProgramPeriodMs kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdProgramPeriodInMilliSeconds(const TDesC& aSection)
{
TInt actualPeriod;
INFO_PRINTF1(_L("Calling MMCStack::ProgramPeriodInMilliSeconds()"));
TInt err = iMmcSDController->StackProgramPeriodInMilliSeconds(actualPeriod);
if (err != KErrNone)
{
ERR_PRINTF2(_L("DMMCStack::ProgramPeriodInMilliSeconds() Error %d"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("DMMCStack::ProgramPeriodInMilliSeconds() actualPeriod(%d)"), actualPeriod);
TInt expectedPeriod;
if (GetIntFromConfig(aSection, KProgramPeriodMs(), expectedPeriod)
&& actualPeriod != expectedPeriod)
{
ERR_PRINTF3(_L("actual (%d) and expected(%d) periods do not match"), actualPeriod, expectedPeriod);
SetBlockResult(EFail);
}
}
}
/**
* Process command that will result in call to DMMCStack::Stop kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdStop(const TDesC& /*aSection*/)
{
INFO_PRINTF1(_L("Calling MMCStack::Stop()"));
TInt err = iMmcSDController->StackStop();
if (err != KErrNone)
{
ERR_PRINTF2(_L("MMCStack::Stop() Error %d"), err);
SetError(err);
}
}
/**
* Process command that will result in call to DMMCStack::Init kernel side
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdInit()
{
INFO_PRINTF1(_L("Calling MMCStack::Init()"));
TInt err = iMmcSDController->StackInit();
if(err != KErrNone)
{
ERR_PRINTF2(_L("MMCStack::Init() Error %d"), err);
SetError(err);
}
}
/**
* Process command that will result in call to DMMCStack::ReportPowerUp kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdReportPowerUp(const TDesC& /*aSection*/)
{
INFO_PRINTF1(_L("Calling MMCStack::ReportPowerUp()"));
TInt err = iMmcSDController->StackReportPowerUp();
if (err != KErrNone)
{
ERR_PRINTF2(_L("MMCStack::ReportPowerUp() Error %d"), err);
SetError(err);
}
}
/**
* Process command that will result in call to DMMCStack::ReportPowerDown kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdReportPowerDown(const TDesC& /*aSection*/)
{
INFO_PRINTF1(_L("Calling MMCStack::ReportPowerDown()"));
TInt err = iMmcSDController->StackReportPowerDown();
if (err != KErrNone)
{
ERR_PRINTF2(_L("MMCStack::ReportPowerDown() Error %d"), err);
SetError(err);
}
}
/**
* Process command that will result in call to DMMCStack::CardP kernel side
*
* @param aSection The section in the ini containing data for the command
*
* @return void
*
* @leave System wide error
*/
void CT_MMCSDStackDriverData::DoCmdCardP(const TDesC& aSection)
{
TCardPtr cardPtr;
if( GetIntFromConfig(aSection, KCardNumber(), cardPtr.iCardNumber) )
{
INFO_PRINTF2(_L("Calling MMCStack::CardP(%d)"), cardPtr.iCardNumber);
TInt err = iMmcSDController->StackCardP(cardPtr);
if( err!=KErrNone )
{
ERR_PRINTF2(_L("MMCStack::CardP() Error %d"), err);
SetError(err);
}
else
{
INFO_PRINTF2(_L("MMCStack::CardP(): ptr=%x"), cardPtr.iCardPtr);
TBool expectedIsNull;
if( GetBoolFromConfig(aSection, KIsNull(), expectedIsNull) )
{
if( expectedIsNull )
{
if( cardPtr.iCardPtr != NULL )
{
ERR_PRINTF1(_L("Card ptr is not NULL"));
SetBlockResult(EFail);
}
}
else
{
if( cardPtr.iCardPtr == NULL )
{
ERR_PRINTF1(_L("Card ptr is NULL"));
SetBlockResult(EFail);
}
}
}
else
{
ERR_PRINTF1(_L("Expected Is Null not given in ini file"));
SetBlockResult(EFail);
}
}
}
else
{
ERR_PRINTF1(_L("Card Number not given in ini file"));
SetBlockResult(EFail);
}
}