--- /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;
+ }
+