// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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 <drivers/mmc.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "locmedia_ost.h"
#ifdef __VC32__
#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"
#endif
#include "sessionTraces.h"
#endif
// -------- class DMMCSession --------
EXPORT_C DMMCSession::DMMCSession(const TMMCCallBack& aCallBack)
/**
* Constructor - initializes callbacks and timers.
* Once the session has been engaged, the completion of the request is signalled by calling
* the function provided in aCallback. A session will be completed in this way if it has completed
* normally, an error has occurred or the session has been stopped by this or another client.
* @param aCallBack reference to a TMMCCallback object to be called upon completion.
*/
: iCallBack(aCallBack),
#ifdef __EPOC32__
iPollTimer(DMMCSession::PollTimerCallBack, this),
iRetryTimer(DMMCSession::RetryTimerCallBack, this),
iProgramTimer(DMMCSession::ProgramTimerCallBack, this),
#endif // #ifdef __EPOC32__
iConfig()
{
OstTraceFunctionEntry1( DMMCSESSION_DMMCSESSION_ENTRY, this );
}
EXPORT_C DMMCSession::~DMMCSession()
/**
* Destructor.
*/
{
OstTraceFunctionEntry1( DUP1_DMMCSESSION_DMMCSESSION_ENTRY, this );
// Ensure that the stack isn't currently running in another thread's context, otherwise this session won't be
// removed from the stack's workset until some time later - by which time the session will have been deleted
__ASSERT_ALWAYS(!iStackP->StackRunning(), DMMCSocket::Panic(DMMCSocket::EMMCNotInDfcContext));
Abort();
UnlockStack();
OstTraceFunctionExit1( DUP1_DMMCSESSION_DMMCSESSION_EXIT, this );
}
EXPORT_C void DMMCSession::SetCard(TMMCard* aCardP)
/**
* Assigns a card to the session. The card pointer would normally be obtained via a call of DMMCStack::CardP().
* Assigning a card to the session is the means by which a particular card in the stack is targeted for a
* particular request. Some requests involve broadcasting to the entire stack. However, the majority involve
* an individual card at some stage of the process and so an attempt to engage the session before a card has
* been assigned to it will generally fail straight away. It is possible to change the card assigned to the
* session as long as this is not attempted while the session is engaged.
* @param aCardP A pointer to the card to be assigned to the session.
*/
{
OstTraceFunctionEntryExt( DMMCSESSION_SETCARD_ENTRY, this );
iCardP = aCardP;
iCID = iCardP->CID();
OstTraceFunctionExit1( DMMCSESSION_SETCARD_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMReadBlock(TMMCArgument aDevAddr, TUint32 aLength, TUint8* aMemoryP)
/**
* Sets the session up to perform the CIM_READ_BLOCK macro as outlined by the MMCA.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* The CIM_READ_BLOCK macro reads a single block from the card. It starts by setting the block length (CMD16) as specified
* in 'aLength'. It then reads a single block of data (CMD17) from the card at offset 'aDevAddr' on the card into system
* memory starting at address 'aMemoryP'.
* @param aDevAddr Contains offset to the block to be read from the card
* @param aLength Block length
* @param aMemoryP host destination address
*/
{
OstTraceExt4(TRACE_FLOW, DMMCSESSION_SETUPCIMREADBLOCK_ENTRY, "DMMCSession::SetupCIMReadBlock;aDevAddr=%x;aLength=%x;aMemoryP=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) aMemoryP, (TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, aMemoryP, aLength);
iSessionID = ECIMReadBlock;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMREADBLOCK_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMWriteBlock(TMMCArgument aDevAddr, TUint32 aLength, TUint8* aMemoryP)
/**
* Set up the session to perform the CIM_WRITE_BLOCK macro as outlined by the MMCA.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* The CIM_WRITE_BLOCK macro writes a single block to the card. It starts by setting the block length (CMD16) as specified
* in 'aLength'. It then writes a single block of data (CMD24) to the card at offset 'aDevAddr' on the card reading from system
* memory starting at address 'aMemoryP'.
* @param aDevAddr Contains offset to the block to be written on the card
* @param aLength Block length
* @param aMemoryP Host source address
*/
{
OstTraceExt4(TRACE_FLOW, DMMCSESSION_SETUPCIMWRITEBLOCK_ENTRY, "DMMCSession::SetupCIMWriteBlock;aDevAddr=%x;aLength=%x;aMemoryP=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) aMemoryP, (TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, aMemoryP, aLength);
iSessionID = ECIMWriteBlock;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMWRITEBLOCK_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMReadMBlock(TMMCArgument aDevAddr, TUint32 aLength, TUint8* aMemoryP, TUint32 aBlkLen)
/**
* Set up the session to perform the CIM_READ_MBLOCK macro as outlined by the MMCA.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* The CIM_READ_MBLOCK macro reads a series of blocks from the card. It starts by setting the block length (CMD16) as specified
* in 'aBlkLen'. It then issues the read multiple block command (CMD18) to continually transfer blocks from the card to host
* starting at offset 'aDevAddr' on the card into system memory starting at address 'aMemoryP'. This continues until 'aLength'
* bytes have been read at which point the Controller issues the stop command (CMD12) to halt the transfer.
* @param aDevAddr Contains offset to the block to be read from the card
* @param aLength Total number of bytes to read.
* @param aMemoryP Host destination address
* @param aBlkLen Block length
*/
{
OstTraceExt5(TRACE_FLOW, DMMCSESSION_SETUPCIMREADMBLOCK_ENTRY, "DMMCSession::SetupCIMReadMBlock;aDevAddr=%x;aLength=%x;aMemoryP=%x;aBlkLen=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) aMemoryP, (TUint) aBlkLen,(TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, aMemoryP, aBlkLen);
iSessionID = ECIMReadMBlock;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMREADMBLOCK_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMWriteMBlock(TMMCArgument aDevAddr, TUint32 aLength, TUint8* aMemoryP, TUint32 aBlkLen)
/**
* Set up the session to perform the CIM_WRITE_MBLOCK macro as outlined by the MMCA.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* The CIM_WRITE_MBLOCK macro writes a series of blocks to the card. It starts by setting the block length (CMD16) as specified
* in 'aBlkLen'. It then issues the write multiple block command (CMD25) to continually transfer blocks from host to the card
* starting at address 'aMemoryP' in system memory and offset 'aDevAddr' on the card.. This continues until 'aLength' bytes have
* been written at which point the Controller issues the stop command (CMD12) to halt the transfer
* @param aDevAddr Contains offset to the block to be written on the card
* @param aLength Total number of bytes to write.
* @param aMemoryP Host source address
* @param aBlkLen Block length
*/
{
OstTraceExt5(TRACE_FLOW, DMMCSESSION_SETUPCIMWRITEMBLOCK_ENTRY, "DMMCSession::SetupCIMWriteMBlock;aDevAddr=%x;aLength=%x;aMemoryP=%x;aBlkLen=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) aMemoryP, (TUint) aBlkLen,(TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, aMemoryP, aBlkLen);
iSessionID = ECIMWriteMBlock;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMWRITEMBLOCK_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMEraseSector(TMMCArgument aDevAddr, TUint32 aLength)
/**
* Set up the session to perform the CIM_ERASE_SECTOR macro broadly as outlined by the MMCA.
* However, the macro only performs a sector erase of a contiguous area and doesn't support the un-tagging of particular sectors
* within the initial tagged area. Having set-up the session for this operation, the client must then engage the session before
* the operation can commence.
* The CIM_ERASE_SECTOR macro erases a range of sectors on the card starting at offset 'aDevAddr' on the card and ending at offset
* 'aDevAdd'+'aLength'. The entire area specified must lie within a single erase group. (The erase group size can be read from the CSD).
* The specified start offset and end offset need not coincide exactly with a sector boundary since the card will ignore LSBs below
* the sector size. The tag sector start command (CMD32) is first issued setting the address of the first sector to be erased.
* This is followed by the tag sector end command (CMD33) setting the address of the last sector to be erased. Now that the erase
* sectors are tagged, the erase command (CMD38) is sent followed by a send status command (CMD13) to read any additional status
* information from the card.
* @param aDevAddr Contains offset to the first block to be erased
* @param aLength Total number of bytes to erase
*/
{
OstTraceExt3(TRACE_FLOW, DMMCSESSION_SETUPCIMERASESECTOR_ENTRY, "DMMCSession::SetupCIMEraseSector;aDevAddr=%x;aLength=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, NULL, 0);
iSessionID = ECIMEraseSector;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMERASESECTOR_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMEraseGroup(TMMCArgument aDevAddr, TUint32 aLength)
/**
* Set up the session to perform the CIM_ERASE_GROUP macro broadly as outlined by the MMCA.
* However, the macro only performs an erase group erase of a contiguous area and doesn't support the un-tagging of particular
* erase groups within the initial tagged area. Having set-up the session for this operation, the client must then engage the
* session before the operation can commence.
* The CIM_ERASE_GROUP macro erases a range of erase groups on the card starting at offset 'aDevAddr' on the card and ending at
* offset 'aDevAdd'+'aLength'. The specified start offset and end offset need not coincide exactly with an erase group boundary
* since the card will ignore LSBs below the erase group size. The tag ease group start command (CMD35) is first issued setting
* the address of the first erase group to be erased. This is followed by the tag erase group end command (CMD36) setting the
* address of the last erase group to be erased. Now that the erase groups are tagged, the erase command (CMD38) is sent followed
* by a send status command (CMD13) to read any additional status information from the card.
* @param aDevAddr Contains offset to the first block to be erased
* @param aLength Total number of bytes to erase
*/
{
OstTraceExt3(TRACE_FLOW, DMMCSESSION_SETUPCIMERASEGROUP_ENTRY, "DMMCSession::SetupCIMEraseGroup;aDevAddr=%x;aLength=%x;this=%x", (TUint) aDevAddr, (TUint) aLength, (TUint) this);
ResetCommandStack();
FillCommandArgs(aDevAddr, aLength, NULL, 0);
iSessionID = ECIMEraseGroup;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMERASEGROUP_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMReadIO(TUint8 aRegAddr, TUint32 aLength, TUint8* aMemoryP)
/**
* Set up the session to perform the read i/o macro (CMD39).
* This macro reads a stream of bytes from an I/O register on a MultiMediaCard. This makes use of the fast i/o (CMD39) command,
* reading 'aLength' bytes of data from I/O register 'aRegAddr' on the card into system memory starting at address 'aMemoryP'.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* @param aRegAddr Address of IO register
* @param aLength Total number of bytes to read
* @param aMemoryP Host destination address
*/
{
OstTraceFunctionEntryExt( DMMCSESSION_SETUPCIMREADIO_ENTRY, this );
ResetCommandStack();
FillCommandArgs(aRegAddr, aLength, aMemoryP, 0);
iSessionID = ECIMReadIO;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMREADIO_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMWriteIO(TUint8 aRegAddr, TUint32 aLength, TUint8* aMemoryP)
/**
* Set up the session to perform the write i/o macro (CMD39).
* This macro writes a stream of bytes to an I/O register on a MultiMediaCard. This makes use of the fast i/o (CMD39) command,
* writing 'aLength' bytes of data to I/O register 'aRegAddr' on the card from system memory starting at address 'aMemoryP'.
* Having set-up the session for this operation, the client must then engage the session before the operation can commence.
* @param aRegAddr Address of IO register
* @param aLength Total number of bytes to write
* @param aMemoryP Host source address
*/
{
OstTraceFunctionEntryExt( DMMCSESSION_SETUPCIMWRITEIO_ENTRY, this );
ResetCommandStack();
FillCommandArgs(aRegAddr, aLength, aMemoryP, 0);
iSessionID = ECIMWriteIO;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMWRITEIO_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCIMLockUnlock(TUint32 aLength, TUint8* aMemoryP)
/**
* Set up the session to perform the lock-unlock macro (CMD42).
* This macro is used to manage the password protection feature (if supported) on a MultiMediaCard.
* This same macro is used to lock or unlock a card, set or clear a password or force erase a card.
* Having set-up the session for the required operation, the client must then engage the session before
* the operation can commence.
* The block length (CMD16) as specified in 'aLength' is first set. The lock unlock command (CMD42) is
* then issued. This command has the same structure as a regular single block write command.
* A data block is written to the card from system memory starting at address 'aMemoryP'. The transferred
* data block should contain the password setting mode, the password length and the password data if appropriate.
* @param aLength Block length
* @param aMemoryP Host source address containing password data
*/
{
OstTraceFunctionEntryExt( DMMCSESSION_SETUPCIMLOCKUNLOCK_ENTRY, this );
__KTRACE_OPT(KPBUS1, Kern::Printf("ms:slu%08x", aLength));
ResetCommandStack();
FillCommandDesc(ECmdLockUnlock);
FillCommandArgs(0, aLength, aMemoryP, aLength);
iSessionID = ECIMLockUnlock;
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMLOCKUNLOCK_EXIT, this );
}
EXPORT_C void DMMCSession::SetupCommand(TMMCCommandEnum aCommand, TMMCArgument anArgument)
/**
* Set up the session to issue a raw command to the card.
* This raw command function should be used when issuing a known command with or without an argument.
* Having set-up the session for this operation, the client must then engage this session before
* the operation can commence.
* @param aCommand Command to be sent
* @param anArgument Associated argument
*/
{
OstTraceExt3(TRACE_FLOW, DMMCSESSION_SETUPCOMMAND_ENTRY, "DMMCSession::SetupCommand;aCommand=%d;anArgument=%x;this=%x", (TInt) aCommand, (TUint) anArgument, (TUint) this);
ResetCommandStack();
FillCommandDesc(aCommand, anArgument);
iSessionID = ECIMNakedSession;
OstTraceFunctionExit1( DMMCSESSION_SETUPCOMMAND_EXIT, this );
}
EXPORT_C void DMMCSession::SetupRSCommand(TMMCCommandEnum aCommand, TMMCArgument anArgument,
TUint32 aResponseLength, TMMCCommandTypeEnum aCommandType,
TMMCResponseTypeEnum aResponseType,
TUint32 aCommandClass)
/**
* Set up the session to issue a raw command to the card.
* This raw command function should be used when issuing an unknown command, an argument and an unknown response type.
* Having set-up the session for this operation, the client must then engage this session before the operation can commence.
* @param aCommand
* @param anArgument
* @param aResponseLength
* @param aCommandType
* @param aResponseType
* @param aCommandClass
* @todo Complete the parameter descriptions
*/
{
OstTraceExt4( TRACE_FLOW, DMMCSESSION_SETUPRSCOMMAND_ENTRY1, "DMMCSession::SetupRSCommand;aCommand=%d;anArgument=%x;aResponseLength=%x;this=%x", (TInt) aCommand, (TUint) anArgument, (TUint) aResponseLength, (TUint) this );
OstTraceExt4( TRACE_FLOW, DMMCSESSION_SETUPRSCOMMAND_ENTRY2, "DMMCSession::SetupRSCommand;aCommandType=%d;aResponseType=%d;aCommandClass=%x;this=%x", (TInt) aCommandType, (TInt) aResponseType, (TUint) aCommandClass, (TUint) this );
ResetCommandStack();
FillCommandDesc(aCommand, anArgument);
TMMCCommandSpec& cmdSpec = Command().iSpec;
cmdSpec.iDirection = EDirNone;
if( aResponseLength <= KMMCMaxResponseLength )
cmdSpec.iResponseLength = aResponseLength;
if( aCommandType != ECmdTypeUK )
cmdSpec.iCommandType = aCommandType;
if( aResponseType != ERespTypeUnknown )
cmdSpec.iResponseType = aResponseType;
if( aCommandClass != KMMCCmdClassNone )
cmdSpec.iCommandClass = aCommandClass;
iSessionID = ECIMNakedSession;
OstTraceFunctionExit1( DMMCSESSION_SETUPRSCOMMAND_EXIT, this );
}
EXPORT_C void DMMCSession::SetupDTCommand(TMMCCommandEnum aCommand, TMMCArgument anArgument,
TUint32 aTotalLength, TUint8* aMemoryAddress, TUint32 aBlockLength,
TBool aStopTransmission, TMMCCmdDirEnum aDir,
TUint32 aCommandClass)
/**
* Set up the session to issue a raw command to the card.
* This raw command function should be used when issuing a generic transfer command and argument.
* Having set-up the session for this operation, the client must then engage this session before
* the operation can commence.
* @param aCommand
* @param anArgument
* @param aTotalLength
* @param aMemoryAddress
* @param aBlockLength
* @param aStopTransmission
* @param aDir
* @param aCommandClass
* @todo Complete the parameter descriptions
*/
{
OstTraceExt5( TRACE_FLOW, DMMCSESSION_SETUPDTCOMMAND_ENTRY1, "DMMCSession::SetupDTCommand;aCommand=%d;anArgument=%x;aTotalLength=%x;aMemoryAddress=%x;this=%x", (TInt) aCommand, (TUint) anArgument, (TUint) aTotalLength, (TUint) aMemoryAddress, (TUint) this );
OstTraceExt5( TRACE_FLOW, DMMCSESSION_SETUPDTCOMMAND_ENTRY2, "DMMCSession::SetupDTCommand;aBlockLength=%x;aStopTransmission=%d;aDir=%d;aCommandClass=%x;this=%x", (TUint) aBlockLength, (TInt) aStopTransmission, (TInt) aDir, (TUint) aCommandClass , (TUint) this );
ResetCommandStack();
FillCommandDesc(aCommand);
FillCommandArgs(anArgument, aTotalLength, aMemoryAddress, aBlockLength);
TMMCCommandDesc& cmd = Command();
if( aBlockLength == 0 )
cmd.iBlockLength = aTotalLength;
cmd.iSpec.iMultipleBlocks = (cmd.iBlockLength != aTotalLength);
if( aStopTransmission )
cmd.iSpec.iUseStopTransmission = ETrue;
if( aDir != EDirNone )
{
cmd.iSpec.iUseStopTransmission = aStopTransmission;
cmd.iSpec.iDirection = aDir;
}
if( aCommandClass != KMMCCmdClassNone )
cmd.iSpec.iCommandClass = aCommandClass;
iSessionID = ECIMNakedSession;
OstTraceFunctionExit1( DMMCSESSION_SETUPDTCOMMAND_EXIT, this );
}
void DMMCSession::SetupCIMControl(TInt aSessID)
//
// find matching macro function for supplied session
//
{
OstTraceFunctionEntryExt( DMMCSESSION_SETUPCIMCONTROL_ENTRY, this );
TMMCSMSTFunc f = GetMacro(aSessID);
if (f == 0)
f = DMMCStack::NoSessionSMST;
iSessionID = (TMMCSessionTypeEnum) aSessID;
iBytesTransferred = 0;
iMMCExitCode = KMMCErrNone;
iState = 0;
iInitContext = 0;
iGlobalRetries = 0;
iDoAbort = iDoStop = iDoComplete = EFalse;
iBlockOn = 0;
ResetCommandStack();
iMachine.Setup(f, iStackP);
OstTraceFunctionExit1( DMMCSESSION_SETUPCIMCONTROL_EXIT, this );
}
EXPORT_C TMMCSMSTFunc DMMCSession::GetMacro(TInt aSessNum) const
{
TMMCSMSTFunc f = 0;
static const TMMCSMSTFunc macros[KMMCMaxSessionTypeNumber] =
{
DMMCStack::NakedSessionSMST,
DMMCStack::CIMUpdateAcqSMST,
DMMCStack::CIMInitStackSMST,
DMMCStack::CIMCheckStackSMST,
DMMCStack::CIMSetupCardSMST,
DMMCStack::CIMReadWriteBlocksSMST, // CIMReadBlock
DMMCStack::CIMReadWriteBlocksSMST, // CIMWriteBlock
DMMCStack::CIMReadWriteBlocksSMST, // CIMReadMBlock
DMMCStack::CIMReadWriteBlocksSMST, // CIMWriteMBlock
DMMCStack::CIMEraseSMST,
DMMCStack::CIMEraseSMST,
DMMCStack::CIMReadWriteIOSMST,
DMMCStack::CIMReadWriteIOSMST,
DMMCStack::CIMLockUnlockSMST, // CIMLockUnlock
DMMCStack::NoSessionSMST, // CIMLockStack is never really executed as a session
DMMCStack::InitStackAfterUnlockSMST,
DMMCStack::CIMAutoUnlockSMST,
DMMCStack::ExecSleepCommandSMST // CIMSleep
};
if (aSessNum >= 0 && aSessNum < (TInt) KMMCMaxSessionTypeNumber)
f = macros[aSessNum];
return f;
}
EXPORT_C TInt DMMCSession::Engage()
/**
* Enque this session for execution on the DMMCStack object which is serving it.
* @return KErrBadDriver if no stack is associated with the session
* @return KErrServerBusy if the stack is currently locked (and KMMCModeEnqueIfLocked flag is cleared)
* @return KErrNotReady if the media is not present
* @return KErrNone if successful
*/
{
OstTraceFunctionEntry1( DMMCSESSION_ENGAGE_ENTRY, this );
__KTRACE_OPT(KPBUS1,Kern::Printf(">ms:eng"));
if( iStackP == NULL )
{
OstTraceFunctionExitExt( DMMCSESSION_ENGAGE_EXIT, this, KErrBadDriver );
return KErrBadDriver;
}
if( iStackP->iLockingSessionP != NULL && iStackP->iLockingSessionP != this &&
(iStackP->EffectiveModes(iConfig) & KMMCModeEnqueIfLocked) == 0 )
{
OstTraceFunctionExitExt( DUP1_DMMCSESSION_ENGAGE_EXIT, this, KErrServerBusy );
return KErrServerBusy;
}
const TMediaState doorState=iStackP->MMCSocket()->iMediaChange->MediaState();
__KTRACE_OPT(KPBUS1,Kern::Printf(">MMC:Eng ds = %x", doorState));
OstTrace1( TRACE_INTERNALS, DMMCSESSION_ENGAGE, "doorState = 0x%x", doorState);
if (doorState == EDoorOpen)
{
OstTraceFunctionExitExt( DUP2_DMMCSESSION_ENGAGE_EXIT, this, KErrNotReady );
return KErrNotReady;
}
SetupCIMControl(iSessionID);
iStackP->Add(this);
__KTRACE_OPT(KPBUS1,Kern::Printf("<ms:eng"));
OstTraceFunctionExitExt( DUP3_DMMCSESSION_ENGAGE_EXIT, this, KErrNone );
return KErrNone;
}
// Command specification table for standard MMC commands (CMD0 - CMD63)
extern const TMMCCommandSpec CommandTable[KMMCCommandMask+1] =
{// Class Type Dir MBlk StopT Rsp Type Len Cmd No
{KMMCCmdClassBasic, ECmdTypeBC, EDirNone, EFalse, EFalse, ERespTypeNone, 0}, //CMD0
{KMMCCmdClassBasic, ECmdTypeBCR, EDirNone, EFalse, EFalse, ERespTypeR3, 4}, //CMD1
{KMMCCmdClassBasic, ECmdTypeBCR, EDirNone, EFalse, EFalse, ERespTypeR2, 16},//CMD2
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD3
{KMMCCmdClassBasic, ECmdTypeBC, EDirNone, EFalse, EFalse, ERespTypeNone, 0}, //CMD4
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR1B, 0}, //CMD5 - SLEEP/AWAKE
{KMMCCmdClassBasic, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1B, 0}, //CMD6
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR1B, 4}, //CMD7
{KMMCCmdClassBasic, ECmdTypeADTCS, EDirRead, EFalse, EFalse, ERespTypeR1, 512}, //CMD8
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR2, 16},//CMD9
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR2, 16},//CMD10
{KMMCCmdClassStreamRead,ECmdTypeADTCS, EDirRead, EFalse, ETrue, ERespTypeR1, 4}, //CMD11
{KMMCCmdClassBasic, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1B, 4}, //CMD12
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD13
{KMMCCmdClassBlockRead, ECmdTypeADTCS, EDirRead, EFalse, EFalse, ERespTypeR1, 4}, //CMD14 - BUSTEST_R
{KMMCCmdClassBasic, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeNone, 0}, //CMD15
{KMMCCmdClassBlockRead, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD16
{KMMCCmdClassBlockRead, ECmdTypeADTCS, EDirRead, EFalse, EFalse, ERespTypeR1, 4}, //CMD17
{KMMCCmdClassBlockRead, ECmdTypeADTCS, EDirRead, ETrue, ETrue, ERespTypeR1, 4}, //CMD18
{KMMCCmdClassBlockWrite,ECmdTypeADTCS, EDirWrite, EFalse, EFalse, ERespTypeR1, 4}, //CMD19 - BUSTEST_W
{KMMCCmdClassStreamWrite,ECmdTypeADTCS, EDirWrite, EFalse, ETrue, ERespTypeR1, 4}, //CMD20
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD21
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD22
{KMMCCmdClassBlockRead |
KMMCCmdClassBlockWrite,ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD23
{KMMCCmdClassBlockWrite,ECmdTypeADTCS, EDirWrite, EFalse, EFalse, ERespTypeR1, 4}, //CMD24
{KMMCCmdClassBlockWrite,ECmdTypeADTCS, EDirWrite, ETrue, ETrue, ERespTypeR1, 4}, //CMD25
{KMMCCmdClassBlockWrite,ECmdTypeADTCS, EDirWrite, EFalse, EFalse, ERespTypeR1, 4}, //CMD26
{KMMCCmdClassBlockWrite,ECmdTypeADTCS, EDirWrite, EFalse, EFalse, ERespTypeR1, 4}, //CMD27
{KMMCCmdClassWriteProtection,ECmdTypeACS,EDirNone, EFalse, EFalse, ERespTypeR1B, 4}, //CMD28
{KMMCCmdClassWriteProtection,ECmdTypeACS,EDirNone, EFalse, EFalse, ERespTypeR1B, 4}, //CMD29
{KMMCCmdClassWriteProtection,ECmdTypeADTCS,EDirRead,EFalse, EFalse, ERespTypeR1, 4}, //CMD30
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD31
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD32
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD33
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD34
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD35
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD36
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD37
{KMMCCmdClassErase, ECmdTypeACS, EDirNone, EFalse, EFalse, ERespTypeR1B, 4}, //CMD38
{KMMCCmdClassIOMode, ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR4, 4}, //CMD39
{KMMCCmdClassIOMode, ECmdTypeBCR, EDirNone, EFalse, EFalse, ERespTypeR5, 4}, //CMD40
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD41
{KMMCCmdClassLockCard, ECmdTypeADTCS, EDirWrite, EFalse, EFalse, ERespTypeR1B, 4}, //CMD42
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD43
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD44
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD45
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD46
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD47
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD48
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD49
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD50
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD51
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD52
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD53
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD54
{KMMCCmdClassApplication,ECmdTypeAC, EDirNone, EFalse, EFalse, ERespTypeR1, 4}, //CMD55
{KMMCCmdClassApplication,ECmdTypeADTCS, EDirRBit0, EFalse, EFalse, ERespTypeR1B, 4}, //CMD56
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD57
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD58
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD59
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD60
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD61
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0}, //CMD62
{KMMCCmdClassNone, ECmdTypeUK, EDirNone, EFalse, EFalse, ERespTypeUnknown, 0} //CMD63
};
EXPORT_C void DMMCSession::FillCommandDesc()
/**
* Fills the current command descriptor with the default data according to MMC spec V2.1
*/
{
OstTraceFunctionEntry1( DMMCSESSION_FILLCOMMANDDESC1_ENTRY, this );
TMMCCommandDesc& cmd = Command();
cmd.iSpec = CommandTable[cmd.iCommand & KMMCCommandMask];
cmd.iFlags = 0;
cmd.iBytesDone = 0;
OstTraceFunctionExit1( DMMCSESSION_FILLCOMMANDDESC1_EXIT, this );
}
EXPORT_C void DMMCSession::FillCommandDesc(TMMCCommandEnum aCommand)
/**
* Initialises the current command according to whether it is a normal
* or an application command.
* @param aCommand Contains the command.
*/
{
OstTraceExt2(TRACE_FLOW, DMMCSESSION_FILLCOMMANDDESC2_ENTRY, "DMMCSession::FillCommandDesc;aCommand=%d;this=%x", (TInt) aCommand, (TUint) this);
Command().iCommand = aCommand;
Command().iArgument = 0; // set stuff bits to zero
FillCommandDesc();
OstTraceFunctionExit1( DMMCSESSION_FILLCOMMANDDESC2_EXIT, this );
}
EXPORT_C void DMMCSession::FillCommandDesc(TMMCCommandEnum aCommand, TMMCArgument anArgument)
/**
* Initialises the current command with an argument according to whether
* it is a normal or an application command.
* @param aCommand Contains the command.
* @param anArgument Specifies the argument.
*/
{
OstTraceExt3(TRACE_FLOW, DMMCSESSION_FILLCOMMANDDESC3_ENTRY, "DMMCSession::FillCommandDesc;aCommand=%d;anArgument=%x;this=%x", (TInt) aCommand, (TUint) anArgument, (TUint) this);
TMMCCommandDesc& cmd = Command();
cmd.iCommand = aCommand;
FillCommandDesc();
cmd.iArgument = anArgument;
OstTraceFunctionExit1( DMMCSESSION_FILLCOMMANDDESC3_EXIT, this );
}
EXPORT_C void DMMCSession::FillCommandArgs(TMMCArgument anArgument, TUint32 aLength, TUint8* aMemoryP,
TUint32 aBlkLen)
/**
* Initialises the current commands arguments with the specified parameters
* It is necessary to have set the command arguments with this command prior
* to engaging a read/write macro or command.
* @param anArgument Command specific argument.
* @param aLength aLength Total number of bytes to read/write.
* @param aMemoryP Host source/destination address
* @param aBlkLen Block length
*/
{
OstTraceExt5(TRACE_FLOW, DMMCSESSION_FILLCOMMANDARGS_ENTRY ,"DMMCSession::FillCommandArgs;anArgument=%x;aLength=%x;aMemoryP=%x;aBlkLen=%x;this=%x", (TUint) anArgument, (TUint) aLength, (TUint) aMemoryP, (TUint) aBlkLen, (TUint) this);
TMMCCommandDesc& cmd = Command();
cmd.iArgument = anArgument;
cmd.iTotalLength = aLength;
cmd.iDataMemoryP = aMemoryP;
cmd.iBlockLength = aBlkLen;
cmd.iFlags = 0;
OstTraceFunctionExit1( DMMCSESSION_FILLCOMMANDARGS_EXIT, this );
}
const TMMCCommandSpec& DMMCSession::FindCommandSpec(const TMMCIdxCommandSpec aSpecs[], TInt aIdx)
/**
* Searches the supplied command specification list for the specification corresponding to the
* supplied command.
* @param aSpecs The command specification list to be searched.
* @param aIdx The requested command.
*/
{
OstTraceFunctionEntry0( DMMCSESSION_FINDCOMMANDSPEC_ENTRY );
TInt i = 0;
while (aSpecs[i].iIdx != aIdx)
++i;
OstTraceFunctionExit0( DMMCSESSION_FINDCOMMANDSPEC_EXIT );
return aSpecs[i].iSpec;
}
void DMMCSession::SynchBlock(TUint32 aFlag)
//
// Blocks a session synchronously (within scheduler context)
//
{
OstTraceFunctionEntryExt( DMMCSESSION_SYNCHBLOCK_ENTRY, this );
(void)__e32_atomic_ior_ord32(&iBlockOn, aFlag);
OstTraceFunctionExit1( DMMCSESSION_SYNCHBLOCK_EXIT, this );
}
void DMMCSession::SynchUnBlock(TUint32 aFlag)
//
// Unblocks a session synchronously (within scheduler context)
//
{
OstTraceFunctionEntryExt( DMMCSESSION_SYNCHUNBLOCK_ENTRY, this );
if( (iBlockOn & aFlag) == 0 )
{
OstTraceFunctionExit1( DMMCSESSION_SYNCHUNBLOCK_EXIT, this );
return;
}
(void)__e32_atomic_and_ord32(&iBlockOn, ~aFlag);
OstTraceFunctionExit1( DUP1_DMMCSESSION_SYNCHUNBLOCK_EXIT, this );
}
EXPORT_C TRCA DMMCSession::CardRCA()
/**
* Checks that the card is still the same and ready
* @return A TRCA object containing the card's RCA (or 0 if the card is not ready)
*/
{
// Rely on 'CardIsGone' bit rather than a CID comparison
if ( iCardP != NULL && iCardP->IsPresent() && !(iState & KMMCSessStateCardIsGone) )
return( iCardP->RCA() );
return(0);
}
#ifdef __EPOC32__
void DMMCSession::ProgramTimerCallBack(TAny* aSessP)
{
OstTraceFunctionEntry0( DMMCSESSION_PROGRAMTIMERCALLBACK_ENTRY );
__KTRACE_OPT(KPBUS1,Kern::Printf("=mss:pgtcb"));
static_cast<DMMCSession *>(aSessP)->iState |= KMMCSessStateDoDFC;
static_cast<DMMCSession *>(aSessP)->UnBlock(KMMCBlockOnPgmTimer, KMMCErrNone);
OstTraceFunctionExit0( DMMCSESSION_PROGRAMTIMERCALLBACK_EXIT );
}
void DMMCSession::PollTimerCallBack(TAny* aSessP)
{
OstTraceFunctionEntry0( DMMCSESSION_POLLTIMERCALLBACK_ENTRY );
__KTRACE_OPT(KPBUS1,Kern::Printf("=mss:ptcb"));
static_cast<DMMCSession *>(aSessP)->iState |= KMMCSessStateDoDFC;
static_cast<DMMCSession *>(aSessP)->UnBlock(KMMCBlockOnPollTimer, KMMCErrNone);
OstTraceFunctionExit0( DMMCSESSION_POLLTIMERCALLBACK_EXIT );
}
void DMMCSession::RetryTimerCallBack(TAny* aSessP)
{
OstTraceFunctionEntry0( DMMCSESSION_RETRYTIMERCALLBACK_ENTRY );
__KTRACE_OPT(KPBUS1,Kern::Printf("=mss:rtcb"));
static_cast<DMMCSession *>(aSessP)->iState |= KMMCSessStateDoDFC;
static_cast<DMMCSession *>(aSessP)->UnBlock(KMMCBlockOnRetryTimer, KMMCErrNone);
OstTraceFunctionExit0( DMMCSESSION_RETRYTIMERCALLBACK_EXIT );
}
#endif // #ifdef __EPOC32__
EXPORT_C TInt DMMCSession::EpocErrorCode() const
/**
* Returns the last Symbian OS style error code returned in this session.
* The Symbian OS error code is derived from both the last MMC specific exit code MMCExitCode()
* and the last status information from the card (iLastStatus).
* @return Standard Symbian OS error code
*/
{
OstTraceFunctionEntry1( DMMCSESSION_EPOCERRORCODE_ENTRY, this );
__KTRACE_OPT(KPBUS1,Kern::Printf("=mss:eee:%08x,%08x", MMCExitCode(), LastStatus().State() ));
OstTraceExt2( TRACE_INTERNALS, DMMCSESSION_EPOCERRORCODE, "MMCExitCode = 0x%08x; LastStatus State = 0x%08x", (TUint) MMCExitCode(), (TUint) LastStatus().State());
struct errorTableEntry
{
TUint32 iMask;
TInt iErrorCode;
};
static const errorTableEntry mmcTable[] =
{
{KMMCErrNotSupported, KErrNotSupported},
{KMMCErrStackNotReady, KErrBadPower},
{KMMCErrArgument, KErrArgument},
{KMMCErrBrokenLock | KMMCErrPowerDown | KMMCErrAbort, KErrAbort},
{KMMCErrNoCard | KMMCErrResponseTimeOut | KMMCErrDataTimeOut |
KMMCErrBusyTimeOut | KMMCErrBusTimeOut, KErrNotReady},
{KMMCErrResponseCRC|KMMCErrDataCRC|KMMCErrCommandCRC, KErrCorrupt},
{KMMCErrLocked, KErrLocked},
{KMMCErrNotFound, KErrNotFound},
{KMMCErrAlreadyExists, KErrAlreadyExists},
{KMMCErrGeneral, KErrGeneral},
{~0UL, KErrUnknown}
};
static const errorTableEntry statusTable[] =
{
{KMMCStatErrOverrun|KMMCStatErrUnderrun|
KMMCStatErrCardECCFailed|KMMCStatErrComCRCError, KErrGeneral},
{KMMCStatErrCSDOverwrite|KMMCStatErrWPViolation, KErrWrite},
{KMMCStatErrLockUnlock, KErrLocked},
{KMMCStatErrIllegalCommand, KErrNotSupported},
{KMMCStatErrEraseParam|KMMCStatErrEraseSeqError|
KMMCStatErrBlockLenError|KMMCStatErrAddressError|
KMMCStatErrOutOfRange, KErrArgument},
{~0UL, KErrUnknown}
};
TUint32 errCode = MMCExitCode();
if( errCode == 0 )
{
OstTraceFunctionExitExt( DMMCSESSION_EPOCERRORCODE_EXIT, this, KErrNone );
return KErrNone;
}
const errorTableEntry* ptr = &mmcTable[0];
if( errCode == KMMCErrStatus )
{
ptr = &statusTable[0];
if( (errCode = LastStatus()) == 0 )
{
OstTraceFunctionExitExt( DUP1_DMMCSESSION_EPOCERRORCODE_EXIT, this, KErrUnknown );
return KErrUnknown;
}
}
for( ;; )
if( (errCode & ptr->iMask) != 0 )
{
TInt ret = ptr->iErrorCode;
OstTraceFunctionExitExt( DUP2_DMMCSESSION_EPOCERRORCODE_EXIT, this, ret );
return ret;
}
else
ptr++;
}