/*
* 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 DMMCSocket
*
* @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::SocketDoControl(TInt aFunction, TAny* a1, TAny* a2)
{
TInt ret=KErrNone;
if (!iSocket)
{
MMCSDLOG("DLddMmcCntrlInterface::SocketDoControl - iSocket is NULL");
return KErrGeneral;
}
else if (!iClient)
{
MMCSDLOG("DLddMmcCntrlInterface::SocketDoControl - iClient is NULL");
return KErrGeneral;
}
switch (TTCFunctionId(aFunction).FunctionId())
{
case RMMCSDTestControllerInterface::ESocket:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocket");
ret = Kern::ThreadRawWrite(iClient, a1, &iSocket, sizeof(iSocket));
}
break;
case RMMCSDTestControllerInterface::ESocketAdjustPartialRead:
{
TPartialReadData partialReadData;
ret = Kern::ThreadRawRead(iClient, a1, &partialReadData, sizeof(partialReadData));
if( ret == KErrNone )
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketAdjustPartialRead");
MMCSDLOG3("start=%d, end=%d", partialReadData.iStart, partialReadData.iEnd);
MMCSDLOG2("cardPtr=%x", iCard);
iSocket->AdjustPartialRead(iCard, partialReadData.iStart, partialReadData.iEnd
, (TUint32*)&(partialReadData.iPhysStart)
, (TUint32*)&(partialReadData.iPhysEnd));
ret = Kern::ThreadRawWrite(iClient, a1, &partialReadData, sizeof(partialReadData));
}
}
break;
case RMMCSDTestControllerInterface::ESocketCardIsPresent:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketCardIsPresent");
TBool cardPresent = iSocket->CardIsPresent();
ret = Kern::ThreadRawWrite(iClient, a1, &cardPresent, sizeof(cardPresent));
}
break;
case RMMCSDTestControllerInterface::ESocketGetBufferInfo:
{
TBufferInfo bufInfo;
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketGetBufferInfo");
iSocket->GetBufferInfo(&bufInfo.iBuf, &bufInfo.iBufLen);
ret = Kern::ThreadRawWrite(iClient, a1, &bufInfo, sizeof(bufInfo));
}
break;
case RMMCSDTestControllerInterface::ESocketInit:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketInit");
ret = iSocket->Init();
}
break;
case RMMCSDTestControllerInterface::ESocketInitiatePowerUpSequence:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketInitiatePowerUpSequence");
iSocket->InitiatePowerUpSequence();
}
break;
case RMMCSDTestControllerInterface::ESocketMachineInfo:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketMachineInfo");
TMachineInfo machineInfo(iSocket->MachineInfo());
ret = Kern::ThreadRawWrite(iClient, a1, &machineInfo, sizeof(machineInfo));
}
break;
case RMMCSDTestControllerInterface::ESocketPrepareStore:
{
TPasswordPrepareStoreData pwdData;
ret = Kern::ThreadRawRead(iClient, a1, &pwdData, sizeof(pwdData));
if( ret == KErrNone )
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketPrepareStore");
MMCSDLOG5("bus=%d, func=%d, newPassword=%S, oldPassword=%S"
, pwdData.iBus, pwdData.iFunc, &pwdData.iNewPassword, &pwdData.iOldPassword);
TLocalDrivePasswordData ld;
if( pwdData.iNewPassword == _L("NULL") )
{
ld.iNewPasswd = NULL;
MMCSDLOG("Using iNewPasswd=NULL");
}
else
{
ld.iNewPasswd = &pwdData.iNewPassword;
}
if( pwdData.iOldPassword == _L("NULL") )
{
ld.iOldPasswd = NULL;
MMCSDLOG("Using iOldPasswd=NULL");
}
else
{
ld.iOldPasswd = &pwdData.iOldPassword;
}
ret = iSocket->PrepareStore(pwdData.iBus, pwdData.iFunc, ld);
}
}
break;
case RMMCSDTestControllerInterface::ESocketReset1:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketReset1");
iSocket->Reset1();
}
break;
case RMMCSDTestControllerInterface::ESocketReset2:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketReset2");
iSocket->Reset2();
}
break;
case RMMCSDTestControllerInterface::ESocketResetInactivity:
{
TInt busNumber;
ret = Kern::ThreadRawRead(iClient, a1, &busNumber, sizeof(busNumber));
if( ret == KErrNone )
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketResetInactivity");
MMCSDLOG2("busNumber=%d", busNumber);
iSocket->ResetInactivity(busNumber);
}
}
break;
case RMMCSDTestControllerInterface::ESocketStack:
{
TStackPtr stackPtr;
ret = Kern::ThreadRawRead(iClient, a1, &stackPtr, sizeof(stackPtr));
if( ret == KErrNone )
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketStack");
MMCSDLOG2("busNumber=%d", stackPtr.iBus);
stackPtr.iStackPtr = iSocket->Stack(stackPtr.iBus);
ret = Kern::ThreadRawWrite(iClient, a1, &stackPtr, sizeof(stackPtr));
}
}
break;
case RMMCSDTestControllerInterface::ESocketiState_Get:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketiState_Get");
MMCSDLOG2("iState=%d", iSocket->iState);
ret = Kern::ThreadRawWrite(iClient, a1, &iSocket->iState, sizeof(iSocket->iState));
}
break;
case RMMCSDTestControllerInterface::ESocketiStandby_Get:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketiStandby_Get");
MMCSDLOG2("iStandby=%d", &iSocket->iStandby);
ret = Kern::ThreadRawWrite(iClient, a1, &iSocket->iStandby, sizeof(iSocket->iStandby));
}
break;
case RMMCSDTestControllerInterface::ESocketiType_Get:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketiType_Get");
MMCSDLOG2("iType=%d", &iSocket->iType);
ret = Kern::ThreadRawWrite(iClient, a1, &iSocket->iType, sizeof(iSocket->iType));
}
break;
case RMMCSDTestControllerInterface::ESocketiDoorOpened_Get:
{
MMCSDLOG("Calling RMMCSDTestControllerInterface::ESocketiDoorOpened_Get");
MMCSDLOG2("iDoorOpened=%d", &iSocket->iDoorOpened);
ret = Kern::ThreadRawWrite(iClient, a1, &iSocket->iDoorOpened, sizeof(iSocket->iDoorOpened));
}
break;
default:
ret=KErrNotFound;
break;
}
return(ret);
}
/**
* Do a kernel side request for DMMCSocket
*
* @param TRequestStatus* aStatus - Request Status
* @param TAny* a1 - Given parameter
* @param TAny* a2 - Given parameter
* @param TInt aCommand - Request Function ID
*
* @return TInt the error code
*
* @leave N/A
*/
TInt DLddMmcCntrlInterface::SocketDoRequest(TRequestStatus* aStatus, TAny* a1, TAny *a2, TInt aCommand)
{
MMCSDLOG2("~~~ SocketDoRequest called iAsyncFunction(%x)", aCommand);
if (!iSocket)
{
MMCSDLOG("DLddMmcCntrlInterface::SocketDoRequest - iSocket is NULL");
return KErrGeneral;
}
TInt ret = KErrNone;
switch (TTCFunctionId(aCommand).FunctionId())
// iAsyncFunction initialized in DoRequest
{
case RMMCSDTestControllerInterface::ESocketPowerUp:
{
MMCSDLOG("Performing RMMCSDTestControllerInterface::ESocketPowerUp");
#ifdef __DEBUG
MMCSDLOG("RMMCSDTestControllerInterface::ESocketPowerUp - Not available in debug build");
ret = KErrNotSupported;
#else
ret = iSocket->PowerUp();
#endif
if ( (ret == KErrNone) || (ret == KErrCompletion) )
{
CreateAsyncBusEventRequest( DLddMmcCntrlInterface::EMMcSocketPowerUp, aStatus, iUnit);
}
else
{
Kern::RequestComplete(iClient, aStatus, ret);
}
}
break;
default:
break;
}
return ret;
}