--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/drivers/pbus/mmc/sdcard/sdcard3c/sdio/function.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,555 @@
+// Copyright (c) 2003-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/sdio/sdio.h>
+#include <drivers/sdio/function.h>
+#include <drivers/sdio/regifc.h>
+#include <drivers/sdio/sdiocard.h>
+#include <drivers/sdio/cisreader.h>
+#include "utraceepbussdio.h"
+
+EXPORT_C TSDIOFunction::TSDIOFunction(TSDIOCard* aCardP, TUint8 aFunctionNumber) :
+/**
+Contructs a TSDIOFunction for the specified card and function number.
+
+@param aCardP A pointer to the card object containing the required function.
+@param aFunctionNumber The number of the function upon which the register interface operates.
+*/
+ iClientHandle(NULL),
+ iRegisterInterfaceP(NULL),
+ iFunctionNumber(aFunctionNumber),
+ iCisPtr(0),
+ iCsaPtr(0),
+ iInterrupt(&aCardP->InterruptController(), aFunctionNumber),
+ iCapabilities(),
+ iCardP(aCardP),
+ iInstanceCount(1)
+ {
+ TRACE3(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionConstructor, reinterpret_cast<TUint32>(this), reinterpret_cast<TUint32>(aCardP), aFunctionNumber); // @SymTraceDataPublishedTvk
+
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionConstructorReturning, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+ }
+
+EXPORT_C TSDIOFunction::~TSDIOFunction()
+/**
+Destroys the TSDIOFunction instance.
+*/
+ {
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDestructor, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+
+ __ASSERT_ALWAYS(iInstanceCount == 0, TSDIOFunction::Panic(TSDIOFunction::ESDIOFunctionBadDeletion));
+ delete iRegisterInterfaceP;
+
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDestructorReturning, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+ }
+
+void TSDIOFunction::Close()
+/**
+Destroys the DSDIORegisterInterface instance.
+*/
+ {
+ TInt oldCount = __e32_atomic_tas_ord32(&iInstanceCount, 1, -1, 0);
+ if (oldCount == 1)
+ delete(this);
+ }
+
+EXPORT_C TInt TSDIOFunction::RegisterClient(DBase* aClientHandle, DMutex* aMutexLockP)
+/**
+@publishedPartner
+@released
+
+Registers the client with the function.
+
+@param aClientHandle The unique Client ID
+@param aMutexLock The client's data access mutex
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunction::DeregisterClient
+*/
+ {
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionRegisterClient, reinterpret_cast<TUint32>(this), reinterpret_cast<TUint32>(aClientHandle)); // @SymTraceDataPublishedTvk
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), ">TSDIOFunction::RegisterClient()");) // @SymTraceDataInternalTechnology
+
+ __ASSERT_DEBUG(aClientHandle != NULL, TSDIOFunction::Panic(TSDIOFunction::ESDIOFunctionBadClientHandle));
+
+ if(iClientHandle != NULL)
+ {
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "ERR:KErrAlreadyExists");) // @SymTraceDataInternalTechnology
+ return(KErrAlreadyExists); // Already registered with a Client
+ }
+
+ iClientHandle = aClientHandle;
+
+ if((iRegisterInterfaceP = new DSDIORegisterInterface(iCardP, iFunctionNumber, aMutexLockP)) == NULL)
+ {
+ TRACE1(TTraceContext(EError), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionRegisterClientOOM, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+ return(KErrNoMemory);
+ }
+
+ __e32_atomic_tas_ord32(&iInstanceCount, 1, 1, 0);
+ iCardP->ClientRegistered();
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "<TSDIOFunction::RegisterClient()")); // @SymTraceDataInternalTechnology
+
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionRegisterClient, reinterpret_cast<TUint32>(this), KErrNone); // @SymTraceDataPublishedTvk
+
+ return(KErrNone);
+ }
+
+EXPORT_C TInt TSDIOFunction::DeregisterClient(DBase* aClientHandle)
+/**
+@publishedPartner
+@released
+
+Deregisters the client from the function.
+
+@param aClientHandle The unique Client ID
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunction::RegisterClient
+
+@todo Need to ensure that all outstanding sessions have completed
+*/
+ {
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDeregisterClient, reinterpret_cast<TUint32>(this), reinterpret_cast<TUint32>(aClientHandle)); // @SymTraceDataPublishedTvk
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), ">TSDIOFunction::DeregisterClient()");) // @SymTraceDataInternalTechnology
+
+ __ASSERT_DEBUG(aClientHandle != NULL, TSDIOFunction::Panic(TSDIOFunction::ESDIOFunctionBadClientHandle));
+
+ TInt ret = KErrPermissionDenied;
+ if(iClientHandle != NULL && (iClientHandle == aClientHandle))
+ {
+ delete iRegisterInterfaceP;
+ iRegisterInterfaceP = NULL;
+
+ iClientHandle = NULL;
+
+ iInterrupt.Unbind();
+
+ iCardP->ClientDeregistered();
+
+ Close();
+
+ ret = KErrNone;
+ }
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "<TSDIOFunction::DeregisterClient()")); // @SymTraceDataInternalTechnology
+
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDeregisterClientReturning, reinterpret_cast<TUint32>(this), ret); // @SymTraceDataPublishedTvk
+
+ return(ret);
+ }
+
+EXPORT_C TInt TSDIOFunction::Enable(TBool aPollReady)
+/**
+@publishedPartner
+@released
+
+Enables the function by writing to the appropriate register in the CCCR.
+
+This function has two modes of operation. If aPollReady == ETrue, then the
+function shall attempt to enable the function, then poll for the recommended
+enable period until the function is enabled, or times out. Otherwise, flow
+returns control to the calling function who should be responsible for polling
+the IO_READY bit (using TSDIOFunction::IsReady)
+
+@param aPollReady Specify ETrue to perform timeout and polling on behalf of the client.
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunction::Disable
+@see TSDIOFunction::IsReady
+*/
+ {
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionEnable, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunction::Enable");) // @SymTraceDataInternalTechnology
+ //
+ // The FBR SHP[1:0] bits determine the power requirements of this function.
+ // If the function 'Requires' high power, then the EHP bit must be set prior
+ // to enabling the function otherwise the function shall not be enabled.
+ //
+ // TODO: This needs to be a little more complex to support 'Optional' HP
+ //
+ TBool enableHighPower = EFalse;
+ switch(iCapabilities.iPowerFlags & KFBRRegPowerSupportMask)
+ {
+ case KFBRRegHighPowerRequired:
+ enableHighPower = ETrue;
+ break;
+ case KFBRRegHighPowerSupported:
+ enableHighPower = ETrue;
+ break;
+ case KFBRRegStandardPower:
+ enableHighPower = EFalse;
+ break;
+ default:
+ enableHighPower = EFalse;
+ break;
+ }
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "Enable High Power: %X",(iCapabilities.iPowerFlags & KFBRRegPowerSupportMask));) // @SymTraceDataInternalTechnology
+
+ TInt err = KErrNone;
+ if(enableHighPower)
+ {
+ err = iCardP->CommonRegisterInterface()->Modify8((KFBRFunctionOffset * iFunctionNumber) + KFBRRegPowerFlags, KFBRRegEnableHighPower, 0);
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "Enabled High Power err:%d",err);) // @SymTraceDataInternalTechnology
+ }
+
+
+ if(err == KErrNone)
+ {
+ // Write to IO Enable Registers
+ err = iCardP->CommonRegisterInterface()->Modify8(KCCCRRegIoEnable, (TUint8)(0x01 << iFunctionNumber), 0x00);
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "Write to IO Enable Registers err:%d",err);) // @SymTraceDataInternalTechnology
+ }
+
+ if((err == KErrNone) && aPollReady)
+ {
+ // Determine the timeout period (this is expressed in 10mS steps)
+ TUint32 timeout = iCapabilities.iEnableTimeout ? iCapabilities.iEnableTimeout : KDefaultFunctionEnableTimeout;
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "Timeout period:%d",timeout);) // @SymTraceDataInternalTechnology
+
+ // Synchronous enable polls here, returning to the calling function
+ // after the function is initialise, or timeout has been exceeded
+ const TUint32 pollPeriod = 100; // 100mS poll period
+ const TUint32 pollCount = (10*timeout) / pollPeriod;
+
+ err = Kern::PollingWait(PollFunctionReady, this, pollPeriod, pollCount); // KErrNone or KErrTimedOut
+ }
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunction::Enable err:%d", err);) // @SymTraceDataInternalTechnology
+
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionEnableReturning, reinterpret_cast<TUint32>(this), err); // @SymTraceDataPublishedTvk
+
+ return(err);
+ }
+
+TBool TSDIOFunction::PollFunctionReady(TAny* aSelfP)
+/**
+Poll function used to determine the state of the function after enable.
+@see TSDIOFunction::Enable
+*/
+ {
+ TSDIOFunction& self = *(TSDIOFunction*)aSelfP;
+
+ TBool isReady = EFalse;
+ (void)self.IsReady(isReady);
+
+ return(isReady);
+ }
+
+EXPORT_C TInt TSDIOFunction::Disable()
+/**
+@publishedPartner
+@released
+
+Disables the function by writing to the appropriate register in the CCCR.
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunction::Enable
+@see TSDIOFunction::IsReady
+*/
+ {
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDisable, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+
+ // Write to IO Enable Registers
+ TInt err = iCardP->CommonRegisterInterface()->Modify8(KCCCRRegIoEnable, 0, TUint8(0x01 << iFunctionNumber));
+ if(err == KErrNone)
+ {
+ err = iCardP->CommonRegisterInterface()->Modify8((KFBRFunctionOffset * iFunctionNumber) + KFBRRegPowerFlags, 0, KFBRRegEnableHighPower);
+ }
+
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionDisable, reinterpret_cast<TUint32>(this), err); // @SymTraceDataPublishedTvk
+ return(err);
+ }
+
+EXPORT_C TInt TSDIOFunction::IsReady(TBool& aIsReady)
+/**
+@publishedPartner
+@released
+
+Used to determine if the function is powered up and ready.
+
+Reads the state of the functions IO_READY to determine if the function is enabled.
+
+@param aIsReady Returns the current state of the function.
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunction::Enable
+@see TSDIOFunction::Disable
+*/
+ {
+ TRACE1(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionIsReady, reinterpret_cast<TUint32>(this)); // @SymTraceDataPublishedTvk
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "Checking whether the function is ready")); // @SymTraceDataInternalTechnology
+
+ TInt err;
+
+ TUint8 ioRdy = EFalse;
+ if((err = iCardP->CommonRegisterInterface()->Read8(KCCCRRegIoReady, &ioRdy)) == KErrNone)
+ {
+ aIsReady = (ioRdy & (0x01 << iFunctionNumber)) != 0;
+ }
+
+ TRACE3(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionIsReadyReturning, reinterpret_cast<TUint32>(this), static_cast<TUint32>(aIsReady), err); // @SymTraceDataPublishedTvk
+
+ return(err);
+ }
+
+EXPORT_C TInt TSDIOFunction::SetPriority(TSDIOFunctionPriority aPriority)
+/**
+This sets the priority of accesses to this function.
+
+This is intended to allow the suspend/resume protocol to determine whether an access to a lower
+priority function should become suspended while a higher priority function is accessed.
+
+Note that the Suspend/Resume protocol is not currently implemented, but may be in a future release.
+
+@param aPriority The requested function priority.
+
+@return KErrNone if successful, otherwise a standard Symbian OS error code.
+
+@see TSDIOFunctionPriority
+*/
+ {
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionSetPriority, reinterpret_cast<TUint32>(this), static_cast<TUint32>(aPriority)); // @SymTraceDataPublishedTvk
+
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionSetPriorityReturning, reinterpret_cast<TUint32>(this), KErrNone); // @SymTraceDataPublishedTvk
+
+ return(KErrNone);
+ }
+
+
+void TSDIOFunction::Panic(TSDIOFunction::TPanic aPanic)
+/**
+Function Panic
+*/
+ {
+ Kern::Fault("SDIO_FN", aPanic);
+ }
+
+
+TInt TSDIOFunction::ParseCIS()
+ {
+ TCisReader iCisRd;
+
+ TInt err = KErrNone;
+
+ const TInt socketNum = iCardP->iStackP->MMCSocket()->iSocketNumber;
+
+ if((err = iCisRd.SelectCis(socketNum,0,0,iFunctionNumber)) == KErrNone)
+ {
+ err = iCisRd.FindReadFunctionConfig(iCapabilities);
+ }
+
+ return err;
+ }
+
+
+EXPORT_C TBool TSDIOFunctionCaps::CapabilitiesMatch(TSDIOFunctionCaps& aCaps, TUint32 aMatchFlags)
+/**
+@publishedPartner
+@released
+
+Compares the capabilities provided in aCaps with the capabilities of the function.
+
+@param aCaps The capabilities provided by the user.
+@param aMatchFlags A bitmask of specific capabilities to match.
+
+@return ETrue if the capabilities match.
+
+@see TSDIOCard::FindFunction
+@see TSDIOFunctionCaps
+@see TSDIOCapsMatch
+*/
+ {
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionCapabilitiesMatch, reinterpret_cast<TUint32>(this), aMatchFlags); // @SymTraceDataPublishedTvk
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunctionCaps::CapabilitiesMatch - aMatchFlags: %d",aMatchFlags);) // @SymTraceDataInternalTechnology
+
+ if(aMatchFlags == TSDIOFunctionCaps::EDontCare)
+ {
+ // Always match if EDontCare is specified
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunctionCaps::CapabilitiesMatch - EDontCare Specified!");) // @SymTraceDataInternalTechnology
+ return(ETrue);
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EFunctionNumber)
+ {
+ // Function numbers must match
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunctionCaps - Match Function Numbers");) // @SymTraceDataInternalTechnology
+ aMatchFlags = (iNumber == aCaps.iNumber) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EFunctionType)
+ {
+ // Function type must match
+ aMatchFlags = (iType == aCaps.iType) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EHasCSA)
+ {
+ // Must contain a Code Storage Area
+ aMatchFlags = (iHasCSA == aCaps.iHasCSA) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EPowerFlags)
+ {
+ // High-Power support requirements must match
+ aMatchFlags = (iPowerFlags == aCaps.iPowerFlags) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EFunctionInfo)
+ {
+ // Specified bits in TPLFE_FUNCTION_INFO definition must match
+ aMatchFlags = ((iFunctionInfo && aCaps.iFunctionInfo) == aCaps.iFunctionInfo) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::ERevision)
+ {
+ // Revision code must match
+ aMatchFlags = (iRevision == aCaps.iRevision) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::ESerialNumber)
+ {
+ // Serial number must match
+ aMatchFlags = (iSerialNumber == aCaps.iSerialNumber) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & ECSASize)
+ {
+ // Size of CSA must be greater than or equal to that requested
+ aMatchFlags = (iCSASize >= aCaps.iCSASize) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & ECSAProperties)
+ {
+ // Specified bits in TPLFE_CSA_PROPERTY definition must match
+ aMatchFlags = ((iCSAProperties && aCaps.iCSAProperties) == aCaps.iCSAProperties) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMaxBlockSize)
+ {
+ // Maximum block size must be greater than or equal to that specified
+ aMatchFlags = (iMaxBlockSize >= aCaps.iMaxBlockSize) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EOcr)
+ {
+ // Requested OCR is must be a subset of the card's supported OCR.
+ aMatchFlags = (iOCR & aCaps.iOCR) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMinPwrStby)
+ {
+ // Minimum Standby Power must not exceed that specified
+ aMatchFlags = (iMinPwrStby <= aCaps.iMinPwrStby) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EAvePwrStby)
+ {
+ // Average Standby Power must not exceed that specified
+ aMatchFlags = (iAvePwrStby <= aCaps.iAvePwrStby) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMaxPwrStby)
+ {
+ // Maximum Standby Power must not exceed that specified
+ aMatchFlags = (iMaxPwrStby <= aCaps.iMaxPwrStby) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMinPwrOp)
+ {
+ // Minimum Operating Power must not exceed that specified
+ aMatchFlags = (iMinPwrOp <= aCaps.iMinPwrOp) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & TSDIOFunctionCaps::EAvePwrOp)
+ {
+ // Average Operating Power must not exceed that specified
+ aMatchFlags = (iAvePwrOp <= aCaps.iAvePwrOp) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMaxPwrOp)
+ {
+ // Maximum Operating Power must not exceed that specified
+ aMatchFlags = (iMaxPwrOp <= aCaps.iMaxPwrOp) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EAveHiPwr)
+ {
+ // Average High Power must not exceed that specified
+ aMatchFlags = (iAveHiPwr <= aCaps.iAveHiPwr) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMaxHiPwr)
+ {
+ // Maximum High Power must not exceed that specified
+ aMatchFlags = (iMaxHiPwr <= aCaps.iMaxHiPwr) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EMinBandwidth)
+ {
+ // Minumum bandwidth must be less than or equal to that specified
+ aMatchFlags = (iMinBandwidth <= aCaps.iMinBandwidth) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EOptBandwidth)
+ {
+ // Optimum bandwidth must be less than or equal to that specified
+ aMatchFlags = (iOptBandwidth <= aCaps.iOptBandwidth) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EStandardFunctionID)
+ {
+ // The standard function ID must match
+ aMatchFlags = (iStandardFunctionID == aCaps.iStandardFunctionID) ? aMatchFlags : 0;
+ }
+ if(aMatchFlags & EStandardFunctionType)
+ {
+ // The standard function type must match
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunctionCaps - Match standard function type");) // @SymTraceDataInternalTechnology
+ aMatchFlags = (iStandardFunctionType == aCaps.iStandardFunctionType) ? aMatchFlags : 0;
+ }
+
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "TSDIOFunctionCaps::CapabilitiesMatch aMatchFlags: 0x%x",aMatchFlags);) // @SymTraceDataInternalTechnology
+ TRACE2(TTraceContext(EBorder), UTraceModuleEPBusSDIO::ESDIOTSDIOFunctionCapabilitiesMatchReturning, reinterpret_cast<TUint32>(this), static_cast<TUint32>(aMatchFlags ? ETrue : EFalse)); // @SymTraceDataPublishedTvk
+
+ return(aMatchFlags ? ETrue : EFalse);
+ }
+
+#ifdef _DEBUG
+void TSDIOFunction::TraceFunctionInfo()
+/**
+Debug function to output the contents of the FBR
+*/
+ {
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iNumber: 0x%02X", iCapabilities.iNumber)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iDevCodeEx: 0x%02X", iCapabilities.iDevCodeEx)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iType: 0x%02X", iCapabilities.iType)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iHasCSA: %d", iCapabilities.iHasCSA)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iPowerFlags: 0x%02X", iCapabilities.iPowerFlags)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iFunctionInfo: 0x%02X", iCapabilities.iFunctionInfo)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iRevision: 0x%02X", iCapabilities.iRevision)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iSerialNumber: 0x%08X", iCapabilities.iSerialNumber)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iCSASize: 0x%08X", iCapabilities.iCSASize)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iCSAProperties: 0x%02X", iCapabilities.iCSAProperties)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMaxBlockSize: 0x%04X", iCapabilities.iMaxBlockSize)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iOCR: 0x%08X", iCapabilities.iOCR)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMinPwrStby: 0x%02X", iCapabilities.iMinPwrStby)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iAvePwrStby: 0x%02X", iCapabilities.iAvePwrStby)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMaxPwrStby: 0x%02X", iCapabilities.iMaxPwrStby)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMinPwrOp: 0x%02X", iCapabilities.iMinPwrOp)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iAvePwrOp: 0x%02X", iCapabilities.iAvePwrOp)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMaxPwrOp: 0x%02X", iCapabilities.iMaxPwrOp)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMinBandwidth: 0x%04X", iCapabilities.iMinBandwidth)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iOptBandwidth: 0x%04X", iCapabilities.iOptBandwidth)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iEnableTimeout: 0x%02X", iCapabilities.iEnableTimeout)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iAveHiPwr: 0x%02X", iCapabilities.iAveHiPwr)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iMaxHiPwr: 0x%02X", iCapabilities.iMaxHiPwr)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iCisPtr: 0x%08X", iCisPtr)); // @SymTraceDataInternalTechnology
+ SYMBIAN_TRACE_SDIO_VERBOSE_ONLY(Printf(TTraceContext(EInternals), "iCsaPtr: 0x%08X", iCsaPtr)); // @SymTraceDataInternalTechnology
+ }
+#endif