diff -r 000000000000 -r cec860690d41 haitest/bspsvs/suite/bsp/mmc/ldd/src/mmclddstack.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/haitest/bspsvs/suite/bsp/mmc/ldd/src/mmclddstack.cpp	Tue Feb 02 01:39:10 2010 +0200
@@ -0,0 +1,371 @@
+/*
+* 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 <kernel.h>
+#include <mmc.h>
+#include <locmedia.h>
+
+#include "mmcldd.h"
+#include "d_mmcsdif.h"
+
+/**
+ * Do a kernel side control for DMMCStack
+ *
+ * @param TInt aFunction - Request Function ID
+ * @param TAny* a1 - Given parameter
+ * @param TAny* a2 - Given parameter
+ *
+ * @return TInt the error code
+ *
+ * @leave N/A
+ */
+TInt DLddMmcCntrlInterface::StackDoControl(TInt aFunction, TAny* a1, TAny* a2)
+	{
+	MMCSDLOG3(
+			"DLddMmcCntrlInterface::StackDoControl aFunction(%d) \
+			TTCFunctionId(aFunction).FunctionId()(%d)",
+			aFunction, TTCFunctionId(aFunction).FunctionId());
+	TInt ret = KErrNone;
+	
+	if (!iStack)
+		{
+  		MMCSDLOG("DLddMmcCntrlInterface::StackDoControl - iStack is NULL");		
+		return KErrGeneral;
+		}
+	else if (!iClient)
+		{
+  		MMCSDLOG("DLddMmcCntrlInterface::StackDoControl - iClient is NULL");		
+		return KErrGeneral;
+		}
+
+	switch (TTCFunctionId(aFunction).FunctionId())
+		{
+		case RMMCSDTestControllerInterface::EStack:
+			{
+			MMCSDLOG("case RMMCSDTestControllerInterface::EStack");
+			ret = Kern::ThreadRawWrite(iClient, a1, &iStack, sizeof(iStack));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackAdjustPartialRead:
+			{
+			if (!iCard)
+				{
+				MMCSDLOG("RMMCSDTestControllerInterface::EStackAdjustPartialRead NULL card\n");
+				return KErrNotReady;
+				}
+
+			TPartialReadData partialReadData;
+			Kern::ThreadRawRead(iClient, a1, &partialReadData,
+					sizeof(partialReadData));
+			iStack->AdjustPartialRead(iCard, partialReadData.iStart,
+					partialReadData.iEnd,
+					(TUint32*)&(partialReadData.iPhysStart),
+					(TUint32*)&(partialReadData.iPhysEnd));
+			ret = Kern::ThreadRawWrite(iClient, a1, &partialReadData,
+					sizeof(partialReadData));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackAllocSession:
+			{
+			// just a simple test to check p1 call of DMMCStack::AllocSession
+			// the session is tested further within the DLddAsyncRequest class
+			// which each uses their own session (allocated from DMMCStack::AllocSession)			
+			MMCSDLOG("pre AllocSession");
+			DMMCSession* session = iStack->AllocSession(TMMCCallBack());
+			MMCSDLOG2("post AllocSession session = %x", session);
+			delete session;
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackBufferInfo:
+			{
+			MMCSDLOG("RMMCSDTestControllerInterface::EStackBufferInfo");
+			TBufferInfo bufInfo;
+			iStack->BufferInfo(bufInfo.iBuf, bufInfo.iBufLen,
+					bufInfo.iMinorBufLen);
+			Kern::ThreadRawWrite(iClient, a1, &bufInfo, sizeof(bufInfo));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackGetBufferInfo:
+			{
+			MMCSDLOG("RMMCSDTestControllerInterface::EStackGetBufferInfo");
+			TBufferInfo bufInfo;
+			iStack->GetBufferInfo(&bufInfo.iBuf, &bufInfo.iBufLen);
+			Kern::ThreadRawWrite(iClient, a1, &bufInfo, sizeof(bufInfo));
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackCardP:
+			{
+     		TCardPtr cardPtr;     		
+      		ret = Kern::ThreadRawRead(iClient, a1, &cardPtr, sizeof(cardPtr));	 
+			if( ret == KErrNone )
+				{
+		  		MMCSDLOG("Calling RMMCSDTestControllerInterface::EStackCardP");
+		  		MMCSDLOG2("cardNumber=%d", cardPtr.iCardNumber);
+		  		iCard = iStack->CardP(cardPtr.iCardNumber);
+		  		MMCSDLOG2("cardPtr=%x", iCard);
+		  		cardPtr.iCardPtr = iCard;
+				ret = Kern::ThreadRawWrite(iClient, a1, &cardPtr, sizeof(cardPtr));
+				}
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackDemandPagingInfo:
+			{
+			DMMCStack::TDemandPagingInfo dpInfo;
+			ret = iStack->DemandPagingInfo(dpInfo);
+
+			if (ret == KErrNone)
+				{
+				TTCDemandPagingInfo info;
+				info.iDriveCount = dpInfo.iDriveCount;
+				info.iNumPages = dpInfo.iNumPages;
+				info.iPagingDriveList = dpInfo.iPagingDriveList;
+				info.iPagingType = dpInfo.iPagingType;
+				info.iReadShift = dpInfo.iReadShift;
+				info.iWriteProtected = dpInfo.iWriteProtected;
+				ret = Kern::ThreadRawWrite(iClient, a1, &info, sizeof(info));
+				}
+			else
+				{
+				MMCSDLOG2(
+						"RMMCSDTestControllerInterface::EStackDemandPagingInfo err(%d)",
+						ret);
+				}
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackEffectiveModes:
+			{
+			TUint32 rval = iStack->EffectiveModes(iStackConfig);
+			ret = Kern::ThreadRawWrite(iClient, a1, &rval, sizeof(rval));
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackHasCardsPresent:
+			{
+			TBool cardsPresent = iStack->HasCardsPresent();
+			ret = Kern::ThreadRawWrite(iClient, a1, &cardsPresent,
+					sizeof(cardsPresent));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackHasSessionsQueued:
+			{
+			TBool sessionsQueued = iStack->HasSessionsQueued();
+			ret = Kern::ThreadRawWrite(iClient, a1, &sessionsQueued,
+					sizeof(sessionsQueued));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackInit:
+			ret = iStack->Init();
+			break;
+		case RMMCSDTestControllerInterface::EStackInitStackInProgress:
+			{
+			TBool inProgress = iStack->InitStackInProgress();
+			ret = Kern::ThreadRawWrite(iClient, a1, &inProgress,
+					sizeof(inProgress));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackMMCSocket:
+			{
+			MMCSDLOG("case RMMCSDTestControllerInterface::EStackMMCSocket");
+			DMMCSocket* socketPtr = iStack->MMCSocket();
+			MMCSDLOG3("Socket Ptr (%x)   &socketPtr(%x)", socketPtr,
+					&socketPtr);
+			ret = Kern::ThreadRawWrite(iClient, a1, &socketPtr,
+					sizeof(socketPtr));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackMachineInfo:
+			{
+			TMMCMachineInfo mi;
+			iStack->MachineInfo(mi);
+			TMachineInfo machineInfo(mi);
+			ret = Kern::ThreadRawWrite(iClient, a1, &machineInfo, sizeof(machineInfo));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackMaxCardsInStack:
+			{
+			TUint maxCards = iStack->MaxCardsInStack();
+			ret = Kern::ThreadRawWrite(iClient, a1, &maxCards, sizeof(maxCards));
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackReadPasswordStore:
+			{
+			TMMCPasswordStore* pps = iStack->PasswordStore();
+			TStackPasswordStoreData pwdStoreData;
+			pwdStoreData.iPwdStorePtr = pps;
+			if (pps)
+				{
+				TBuf8<KPasswordStoreCIDLength + KMmcPwdLen> formattedPassword;
+				ret = pps->ReadPasswordData(formattedPassword);
+				MMCSDLOG2("RMMCSDTestControllerInterface::EStackReadPasswordStore formattedPassword=%S", &formattedPassword);
+				
+				if (ret == KErrNone)
+					{
+					pwdStoreData.SetFormattedPassword(formattedPassword);
+					ret = Kern::ThreadRawWrite(iClient, a1, &pwdStoreData, sizeof(pwdStoreData));
+					}
+				}
+			else
+				{
+				MMCSDLOG("RMMCSDTestControllerInterface::EStackReadPasswordStore invalid pps");
+				ret = KErrGeneral;
+				}
+
+			MMCSDLOG3("RMMCSDTestControllerInterface::EStackReadPasswordStore #1 ret(%d) pwdStoreData.iPassword(%S)",
+						ret, &pwdStoreData.iPassword);
+			}
+			break;
+		case RMMCSDTestControllerInterface::EStackWritePasswordStore:
+			{
+			TStackPasswordStoreData pwdStoreData;
+			ret = Kern::ThreadRawRead(iClient, a1, &pwdStoreData, sizeof(pwdStoreData));
+			TMMCPasswordStore* pps = iStack->PasswordStore();
+			pwdStoreData.iPwdStorePtr = pps;
+			if (pps)
+				{
+				TBuf8<KPasswordStoreCIDLength + KMmcPwdLen> formattedPassword;
+				if (pwdStoreData.CreateFormattedPassword(formattedPassword, iCard->CID()))
+					{
+					MMCSDLOG2("RMMCSDTestControllerInterface::EStackWritePasswordStore formattedPassword=%S", &formattedPassword);
+					ret = pps->WritePasswordData(formattedPassword);				
+					}
+				else
+					{
+					MMCSDLOG("RMMCSDTestControllerInterface::EStackWritePasswordStore - CreateFormattedPassword() failed");
+					ret = KErrGeneral;
+					}
+				}
+			else
+				{
+				MMCSDLOG("RMMCSDTestControllerInterface::EStackWritePasswordStore invalid pps");
+				ret = KErrGeneral;
+				}
+			MMCSDLOG3(
+					"RMMCSDTestControllerInterface::EStackWritePasswordStore ret(%d) pwdStoreData.iPassword(%S)",
+					ret, &pwdStoreData.iPassword);
+			}
+			break;
+			
+		case RMMCSDTestControllerInterface::EStackProgramPeriodInMs:
+			{
+			TInt periodMs = iStack->ProgramPeriodInMilliSeconds();
+			ret
+					= Kern::ThreadRawWrite(iClient, a1, &periodMs,
+							sizeof(periodMs));
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackStop:
+			{
+			if (!iCard)
+				{
+				MMCSDLOG("RMMCSDTestControllerInterface::EStackStop NULL card\n");
+				return KErrNotReady;
+				}
+
+			ret = iStack->Stop(iCard);
+			}
+			break;
+
+		case RMMCSDTestControllerInterface::EStackReportPowerUp:
+			iStack->ReportPowerUp();
+			break;
+			
+		case RMMCSDTestControllerInterface::EStackReportPowerDown:
+			iStack->ReportPowerDown();
+			break;
+			
+		case RMMCSDTestControllerInterface::EStackConfigureEffectiveModes:
+			if (!a1)
+				{
+				return KErrArgument;
+				}
+			ret = StackConfigureEffectiveModes((TInt) a1, a2);
+			break;
+
+		default:
+			ret = KErrNotFound;
+			break;
+		}
+	return ret;
+	}
+
+/**
+ * Configure the Effectivemodes parameter for all TMMCStackConfig functions
+ *
+ * @param TInt aEffectiveModesFunctionId - Effective Modes Function ID
+ * @param TAny* aParam - Given Effective Modes Function parameter
+ *
+ * @return TInt the error code
+ *
+ * @leave N/A
+ */
+TInt DLddMmcCntrlInterface::StackConfigureEffectiveModes(
+		TInt aEffectiveModesFunctionId, TAny* aParam)
+	{
+	// used to handle requests to configure the iStackConfig (Effectivemodes)
+	// parameter for all TMMCStackConfig functions is max 32 bit value so passes in as value aParam
+
+	TInt r = KErrNone; // all functions return void	
+	switch ((RMMCSDTestControllerInterface::TEffectiveModesFunctionId) aEffectiveModesFunctionId)
+		{
+		case RMMCSDTestControllerInterface::EStackEffectiveModesRemoveMode:
+			iStackConfig.RemoveMode((TUint32)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetBusClockInKhz:
+			iStackConfig.SetBusClockInKhz((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetBusyTimeOutInMcs:
+			iStackConfig.SetBusyTimeOutInMcs((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetCRCRetries:
+			iStackConfig.SetCRCRetries((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetDataTimeOutInMcs:
+			iStackConfig.SetDataTimeOutInMcs((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetMode:
+			iStackConfig.SetMode((TUint32)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetOpCondBusyTimeout:
+			iStackConfig.SetOpCondBusyTimeout((TUint16)((TInt)aParam));
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetPollAttempts:
+			iStackConfig.SetPollAttempts((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetResponseTimeOutInTicks:
+			iStackConfig.SetResponseTimeOutInTicks((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetTicksClockIn:
+			iStackConfig.SetTicksClockIn((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetTicksClockOut:
+			iStackConfig.SetTicksClockOut((TUint)aParam);
+			break;
+		case RMMCSDTestControllerInterface::EStackEffectiveModesSetTimeOutRetries:
+			iStackConfig.SetTimeOutRetries((TUint)aParam);
+			break;
+		default:
+			r = KErrNotFound;
+			break;
+		};
+	return r;
+	}
+