diff -r d3e8e7d462dd -r f92a4f87e424 usbmgmt/usbmgr/usbman/server/SRC/CUsbSession.cpp --- a/usbmgmt/usbmgr/usbman/server/SRC/CUsbSession.cpp Thu Jul 15 20:42:20 2010 +0300 +++ b/usbmgmt/usbmgr/usbman/server/SRC/CUsbSession.cpp Tue Aug 31 17:01:47 2010 +0300 @@ -1,5 +1,5 @@ /* -* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +* Copyright (c) 1997-2010 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" @@ -20,7 +20,11 @@ @file */ +#include +#include +#include #include + #include "CUsbSession.h" #include "CUsbDevice.h" #include "CUsbServer.h" @@ -30,17 +34,15 @@ #include "cusbhost.h" #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV -#include -#include - -#include #include "CPersonality.h" #include "rusb.h" #include "UsbSettings.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "CUsbSessionTraces.h" +#endif -#ifdef __FLOG_ACTIVE -_LIT8(KLogComponent, "USBSVR"); -#endif + #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV CUsbSession* CUsbSession::iCtlSession = NULL; @@ -56,7 +58,7 @@ */ CUsbSession* CUsbSession::NewL(CUsbServer* aServer) { - LOG_STATIC_FUNC_ENTRY + OstTraceFunctionEntry0( CUSBSESSION_NEWL_ENTRY ); //this class has moved away from standard NewL() semantics //and now uses the virtual CSession2::CreateL() function @@ -75,9 +77,10 @@ CUsbSession::CUsbSession(CUsbServer* aServer) : iUsbServer(aServer) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_CONS_ENTRY ); iUsbServer->IncrementSessionCount(); + OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_CONS_EXIT ); } @@ -86,18 +89,18 @@ */ CUsbSession::~CUsbSession() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_DES_ENTRY ); - LOGTEXT2(_L8("About to Device().DeRegisterObserver(%08x"),this); + OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION, "CUsbSession::~CUsbSession;About to Device().DeRegisterObserver(%08x)", this ); iUsbServer->Device().DeRegisterObserver(*this); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV #ifndef __OVER_DUMMYUSBDI__ - LOGTEXT2(_L8("About to Otg().DeRegisterObserver(%08x"),this); + OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP1, "CUsbSession::~CUsbSession;About to Otg().DeRegisterObserver(%08x)", this ); iUsbServer->Otg().DeRegisterObserver(*this); #endif - LOGTEXT2(_L8("About to Host().DeRegisterObserver(%08x"),this); + OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP2, "CUsbSession::~CUsbSession;About to Host().DeRegisterObserver(%08x)", this ); iUsbServer->Host().DeregisterObserver(*this); if ( iCtlSession && (iCtlSession == this) ) @@ -106,8 +109,9 @@ } #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV - LOGTEXT(_L8("About to iUsbServer->DecrementSessionCount()")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP3, "CUsbSession::~CUsbSession;About to iUsbServer->DecrementSessionCount()" ); iUsbServer->DecrementSessionCount(); + OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_DES_EXIT ); } @@ -118,9 +122,10 @@ */ void CUsbSession::ServiceL(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_SERVICEL_ENTRY ); DispatchMessageL(aMessage); + OstTraceFunctionExit0( CUSBSESSION_SERVICEL_EXIT ); } /** @@ -130,7 +135,7 @@ */ void CUsbSession::CreateL() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_CREATEL_ENTRY ); // This code originally existed in the typical non-virtual ConstructL() method. // However it was moved to this method for minor optimisation reasons [three less @@ -138,18 +143,19 @@ iPersonalityCfged = iUsbServer->Device().isPersonalityCfged(); - LOGTEXT(_L8("Registering Device Observer\n")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL, "CUsbSession::CreateL;Registering Device Observer" ); iUsbServer->Device().RegisterObserverL(*this); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV #ifndef __OVER_DUMMYUSBDI__ - LOGTEXT(_L8("Registering OTG Observer\n")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP1, "CUsbSession::CreateL;Registering OTG Observer" ); iUsbServer->Otg().RegisterObserverL(*this); #endif - LOGTEXT(_L8("Registering HOST Observer\n")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP2, "CUsbSession::CreateL;Registering HOST Observer" ); iUsbServer->Host().RegisterObserverL(*this); #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV + OstTraceFunctionExit0( CUSBSESSION_CREATEL_EXIT ); } /** @@ -163,8 +169,8 @@ void CUsbSession::UsbServiceStateChange(TInt aLastError, TUsbServiceState aOldState, TUsbServiceState aNewState) { - LOG_FUNC - LOGTEXT3(_L8(" aOldState=0x%X, aNewState=0x%X"), aOldState, aNewState); + OstTraceFunctionEntry0( CUSBSESSION_USBSERVICESTATECHANGE_ENTRY ); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBSERVICESTATECHANGE, "CUsbSession::UsbServiceStateChange;aOldState=0x%X, aNewState=0x%X", aOldState, aNewState ); (void) aOldState; // a-void build warning in UREL // Note that it's possible to have both a start and a stop outstanding! @@ -188,6 +194,7 @@ const TInt err = iServiceObserverMessage.Write(0, pckg); iServiceObserverMessage.Complete(err); } + OstTraceFunctionExit0( CUSBSESSION_USBSERVICESTATECHANGE_EXIT ); } /** @@ -199,17 +206,17 @@ void CUsbSession::HandleServiceStateChangeWhileStarting(TInt aLastError, TUsbServiceState aNewState) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_ENTRY ); switch (aNewState) { case EUsbServiceStarted: - LOGTEXT(_L8(" Completing Start successfully")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING, "CUsbSession::HandleServiceStateChangeWhileStarting Completing Start successfully" ); // If the user has tried to cancel the start, they're too late! if (iCancelOutstanding) { - LOGTEXT(_L8(" Completing cancel request with KErrNone")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStarting Completing cancel request with KErrNone" ); iCancelOutstanding = EFalse; iCancelMessage.Complete(KErrNone); } @@ -219,7 +226,7 @@ break; case EUsbServiceIdle: - LOGTEXT2(_L8(" Completing Start with error=%d"), aLastError); + OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStarting; Completing Start with error=%d", aLastError ); // If there hasn't actually been an error, but we're in an unexpected // state now, that means that this client cancelled the request, or @@ -230,7 +237,7 @@ // the start message should be completed with KErrCancel. if (iCancelOutstanding) { - LOGTEXT(_L8(" Completing original message with KErrCancel")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStarting Completing original message with KErrCancel" ); iCancelOutstanding = EFalse; iCancelMessage.Complete(KErrNone); iStartMessage.Complete(KErrCancel); @@ -258,6 +265,7 @@ default: break; } + OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_EXIT ); } /** @@ -269,12 +277,12 @@ void CUsbSession::HandleServiceStateChangeWhileStopping(TInt aLastError, TUsbServiceState aNewState) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_ENTRY ); switch (aNewState) { case EUsbServiceStarted: - LOGTEXT2(_L8(" Completing Stop with error=%d"), aLastError); + OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING, "CUsbSession::HandleServiceStateChangeWhileStopping; Completing Stop with error=%d", aLastError ); // If there hasn't actually been an error, but we're in an unexpected // state now, that means that this client cancelled the request, or @@ -285,7 +293,7 @@ // the stop message should be completed with KErrCancel. if (iCancelOutstanding) { - LOGTEXT(_L8(" Completing original message with KErrCancel")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStopping; Completing original message with KErrCancel" ); iCancelOutstanding = EFalse; iCancelMessage.Complete(KErrNone); iStopMessage.Complete(KErrCancel); @@ -311,12 +319,12 @@ break; case EUsbServiceIdle: - LOGTEXT(_L8(" Completing Stop with KErrNone")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStopping Completing Stop with KErrNone" ); // If the user has tried to cancel the stop, they're too late! if (iCancelOutstanding) { - LOGTEXT(_L8(" Completing cancel request with KErrNone")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStopping Completing cancel request with KErrNone" ); iCancelOutstanding = EFalse; iCancelMessage.Complete(KErrNone); } @@ -328,6 +336,7 @@ default: break; } + OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_EXIT ); } /** @@ -343,7 +352,7 @@ void CUsbSession::UsbDeviceStateChange(TInt /*aLastError*/, TUsbDeviceState /*aOldState*/, TUsbDeviceState aNewState) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBDEVICESTATECHANGE_ENTRY ); // can we bypass the queue? if ((iDeviceObserverOutstanding) && (iDevStateQueueHead == iDevStateQueueTail)) @@ -384,9 +393,8 @@ if (aNewState == iDeviceStateQueue[queuePtr]) { // Event is already queued; discard the duplicate and in-between events - LOGTEXT3(_L8("--- collapsing queue head (%d, %d)"), - iDevStateQueueHead, - (queuePtr + 1) % KDeviceStatesQueueSize); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE, "CUsbSession::UsbDeviceStateChange;--- collapsing queue head (%d, %d)", iDevStateQueueHead, ((queuePtr + 1) % KDeviceStatesQueueSize) ); + // queue head moved to position following the match iDevStateQueueHead = (queuePtr + 1) % KDeviceStatesQueueSize; @@ -405,13 +413,13 @@ // add event to head of queue iDeviceStateQueue[iDevStateQueueHead] = aNewState; iDevStateQueueHead = (iDevStateQueueHead + 1) % KDeviceStatesQueueSize; - LOGTEXT3(_L8("+++ addqueue (%d, %d)"), iDevStateQueueHead, - iDevStateQueueTail); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE_DUP1, "CUsbSession::UsbDeviceStateChange;+++ addqueue (%d, %d)", iDevStateQueueHead, iDevStateQueueTail ); } // UsbDeviceDequeueEvent() will read from queue when RegisterObserver() // is next called. } + OstTraceFunctionExit0( CUSBSESSION_USBDEVICESTATECHANGE_EXIT ); } /** @@ -419,7 +427,7 @@ */ void CUsbSession::UsbDeviceDequeueEvent() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_ENTRY ); // Work our way through the queue, until we reach the end // OR we find an event the current observer wants. @@ -440,7 +448,7 @@ iNotifiedDevState = newState; - LOGTEXT3(_L8(">>> dequeued event #%d (0x%x)"), iDevStateQueueTail, newState); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICEDEQUEUEEVENT, "CUsbSession::UsbDeviceDequeueEvent;dequeued event #%d (0x%x)", iDevStateQueueTail, newState ); iDeviceObserverOutstanding = EFalse; const TInt err = iDeviceObserverMessage.Write(1, pckg); @@ -448,6 +456,7 @@ break; } } + OstTraceFunctionExit0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_EXIT ); } /** @@ -458,12 +467,12 @@ */ void CUsbSession::DispatchMessageL(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_DISPATCHMESSAGEL_ENTRY ); TBool complete = ETrue; TInt ret = KErrNone; - LOGTEXT2(_L8("CUsbSession::DispatchMessageL(): func# %d"), aMessage.Function()); + OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL, "CUsbSession::DispatchMessageL;func#=%d", aMessage.Function() ); switch (aMessage.Function()) { @@ -518,9 +527,6 @@ case EUsbGetDescription: ret = GetDescription(aMessage); break; - case EUsbGetDetailedDescription: - ret = GetDetailedDescription(aMessage); - break; case EUsbGetPersonalityProperty: ret = GetPersonalityProperty(aMessage); break; @@ -532,20 +538,20 @@ // Heap failure debug APIs. case EUsbDbgMarkHeap: - LOGTEXT(_L8("Marking heap")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP1, "CUsbSession::DispatchMessageL;Marking heap" ); __UHEAP_MARK; break; case EUsbDbgCheckHeap: - LOGTEXT2(_L8("Checking heap (expecting %d cells)"), aMessage.Int0()); + OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP2, "CUsbSession::DispatchMessageL;Checking heap (expecting %d cells)", aMessage.Int0() ); __UHEAP_CHECK(aMessage.Int0()); break; case EUsbDbgMarkEnd: - LOGTEXT2(_L8("End of marking heap (expecting %d cells)"), aMessage.Int0()); + OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP3, "CUsbSession::DispatchMessageL;End of marking heap (expecting %d cells)", aMessage.Int0() ); __UHEAP_MARKENDC(aMessage.Int0()); break; case EUsbDbgFailNext: { - LOGTEXT2(_L8("Simulating failure after %d allocation(s)"), aMessage.Int0()); + OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP4, "CUsbSession::DispatchMessageL;Simulating failure after %d allocation(s)", aMessage.Int0() ); if (aMessage.Int0() == 0) __UHEAP_RESET; else @@ -556,7 +562,7 @@ { ret = KErrNone; #ifdef _DEBUG - LOGTEXT(_L8("\tallocate on the heap")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP5, "CUsbSession::DispatchMessageL;allocate on the heap" ); TInt* x = NULL; TRAP(ret, x = new(ELeave) TInt); delete x; @@ -646,7 +652,7 @@ #endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV default: - LOGTEXT2(_L8("Illegal IPC argument(%d) - Panicking Client..."), aMessage.Function()); + OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL_DUP6, "CUsbSession::DispatchMessageL;Illegal IPC argument(%d) - Panicking Client...", aMessage.Function() ); aMessage.Panic(KUsbCliPncCat, EUsbPanicIllegalIPC); complete = EFalse; break; @@ -654,6 +660,7 @@ if (complete) aMessage.Complete(ret); + OstTraceFunctionExit0( CUSBSESSION_DISPATCHMESSAGEL_EXIT ); } @@ -666,12 +673,13 @@ */ TInt CUsbSession::StartDeviceL(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_STARTDEVICEL_ENTRY ); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // Only 'control' session is allowed to start USB support if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT ); return KErrAccessDenied; } #endif @@ -705,6 +713,7 @@ iStartOutstanding = ETrue; } + OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT_DUP1 ); return KErrNone; #else @@ -715,6 +724,7 @@ iStartOutstanding = EFalse; aMessage.IsNull(); aComplete = ETrue; + OstTraceFunctionExit0( CUSBSESSION_STARTDEVICEL_EXIT_DUP2 ); return KErrNone; #endif @@ -729,18 +739,20 @@ */ TInt CUsbSession::StopDeviceL(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_STOPDEVICEL_ENTRY ); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // Only 'control' session is allowed to stop USB support if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT ); return KErrAccessDenied; } #endif if (iStopOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP1 ); return KErrInUse; } @@ -760,6 +772,7 @@ iStopOutstanding = ETrue; } + OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP2 ); return KErrNone; #else @@ -770,6 +783,7 @@ aComplete = ETrue; aMessage.IsNull(); iStopOutstanding = EFalse; + OstTraceFunctionExit0( CUSBSESSION_STOPDEVICEL_EXIT_DUP3 ); return KErrNone; #endif @@ -786,12 +800,13 @@ */ TInt CUsbSession::StartCancel(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_STARTCANCEL_ENTRY ); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // Only 'control' session is allowed to cancel outstaning start request if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_STARTCANCEL_EXIT ); return KErrAccessDenied; } #endif @@ -811,6 +826,7 @@ #endif } + OstTraceFunctionExit0( CUSBSESSION_STARTCANCEL_EXIT_DUP1 ); return KErrNone; } @@ -825,18 +841,19 @@ */ TInt CUsbSession::StopCancel(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC - + OstTraceFunctionEntry0( CUSBSESSION_STOPCANCEL_ENTRY ); #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // Only 'control' session is allowed to cancel outstaning stop request if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT ); return KErrAccessDenied; } #endif if (!iStopOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT_DUP1 ); return KErrNone; } @@ -850,6 +867,7 @@ return errHost; #endif TRAPD(err, iUsbServer->Device().StartL()); + OstTraceFunctionExit0( CUSBSESSION_STOPCANCEL_EXIT_DUP2 ); return err; } @@ -865,10 +883,11 @@ */ TInt CUsbSession::RegisterDeviceObserver(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_REGISTERDEVICEOBSERVER_ENTRY ); if (iDeviceObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_REGISTERDEVICEOBSERVER_EXIT ); return KErrInUse; } @@ -880,7 +899,7 @@ { // This is the first observer after c'tor or DeregisterObserver(), // so zap the device event queue. - LOGTEXT(_L8(" Reset Device Event Queue")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERDEVICEOBSERVER, "CUsbSession::RegisterDeviceObserver Reset Device Event Queue" ); iDevStateQueueHead = 0; iDevStateQueueTail = 0; iObserverQueueEvents = ETrue; @@ -891,6 +910,7 @@ UsbDeviceDequeueEvent(); } + OstTraceFunctionExit0( CUSBSESSION_REGISTERDEVICEOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -906,16 +926,18 @@ */ TInt CUsbSession::RegisterServiceObserver(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_REGISTERSERVICEOBSERVER_ENTRY ); if (iServiceObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_REGISTERSERVICEOBSERVER_EXIT ); return KErrInUse; } iServiceObserverMessage = aMessage; iServiceObserverOutstanding = ETrue; aComplete = EFalse; + OstTraceFunctionExit0( CUSBSESSION_REGISTERSERVICEOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -931,10 +953,10 @@ */ TInt CUsbSession::GetCurrentServiceState(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTSERVICESTATE_ENTRY ); TUsbServiceState state = iUsbServer->Device().ServiceState(); - LOGTEXT2(_L8("\tstate = %d"), state); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTSERVICESTATE, "CUsbSession::GetCurrentServiceState;state=%d", state ); TPckg pckg(state); return aMessage.Write(0, pckg); } @@ -950,10 +972,10 @@ */ TInt CUsbSession::GetCurrentDeviceState(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTDEVICESTATE_ENTRY ); TUsbDeviceState state = iUsbServer->Device().DeviceState(); - LOGTEXT2(_L8("\tstate = %d"), state); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTDEVICESTATE, "CUsbSession::GetCurrentDeviceState;state=%d", state ); TPckg pckg(state); return aMessage.Write(0, pckg); } @@ -968,10 +990,11 @@ */ TInt CUsbSession::DeRegisterDeviceObserver() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_ENTRY ); if (!iDeviceObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_EXIT ); return KErrNone; } @@ -981,6 +1004,7 @@ // client doesn't need events queuing any more iObserverQueueEvents = EFalse; + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERDEVICEOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -993,15 +1017,17 @@ */ TInt CUsbSession::DeRegisterServiceObserver() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_ENTRY ); if (!iServiceObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_EXIT ); return KErrNone; } iServiceObserverOutstanding = EFalse; iServiceObserverMessage.Complete(KErrCancel); + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERSERVICEOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -1015,7 +1041,7 @@ */ TInt CUsbSession::TryStartDeviceL(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_TRYSTARTDEVICEL_ENTRY ); #ifndef __OVER_DUMMYUSBDI__ @@ -1023,17 +1049,20 @@ // Only 'control' session is allowed to start USB support if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT ); return KErrAccessDenied; } #endif if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP1 ); return KErrNotSupported; } if (iStartOutstanding || iStopOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP2 ); return KErrServerBusy; } @@ -1070,6 +1099,7 @@ { if (aMessage.Int0() != iUsbServer->Device().CurrentPersonalityId()) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP3 ); return KErrAbort; } @@ -1082,9 +1112,11 @@ } else if (state == EUsbServiceStopping) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP4 ); return KErrServerBusy; } + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP5 ); return KErrNone; #else @@ -1095,6 +1127,7 @@ iStartOutstanding = EFalse; aMessage.IsNull(); aComplete = ETrue; + OstTraceFunctionExit0( CUSBSESSION_TRYSTARTDEVICEL_EXIT_DUP6 ); return KErrNone; #endif } @@ -1109,7 +1142,7 @@ */ TInt CUsbSession::TryStopDeviceL(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_TRYSTOPDEVICEL_ENTRY ); #ifndef __OVER_DUMMYUSBDI__ @@ -1117,17 +1150,20 @@ // Only 'control' session is allowed to stop USB support if ( !iSessionCtlMode ) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT ); return KErrAccessDenied; } #endif if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP1 ); return KErrNotSupported; } if (iStartOutstanding || iStopOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP2 ); return KErrServerBusy; } @@ -1157,6 +1193,7 @@ } else if (state == EUsbServiceStarting) { + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP3 ); return KErrServerBusy; } else if (state == EUsbServiceStopping) @@ -1166,6 +1203,7 @@ iStopOutstanding = ETrue; } + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP4 ); return KErrNone; #else @@ -1176,6 +1214,7 @@ aMessage.IsNull(); aComplete = ETrue; iStopOutstanding = EFalse; + OstTraceFunctionExit0( CUSBSESSION_TRYSTOPDEVICEL_EXIT_DUP5 ); return KErrNone; #endif } @@ -1190,10 +1229,11 @@ */ TInt CUsbSession::CancelInterest(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_CANCELINTEREST_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_CANCELINTEREST_EXIT ); return KErrNotSupported; } @@ -1215,6 +1255,7 @@ } } + OstTraceFunctionExit0( CUSBSESSION_CANCELINTEREST_EXIT_DUP1 ); return KErrCancel; } @@ -1227,15 +1268,16 @@ */ TInt CUsbSession::GetCurrentPersonalityId(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETCURRENTPERSONALITYID_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_GETCURRENTPERSONALITYID_EXIT ); return KErrNotSupported; } TInt currentPersonalityId = iUsbServer->Device().CurrentPersonalityId(); - LOGTEXT2(_L8("\tcurrentPersonalityId = %d"), currentPersonalityId); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETCURRENTPERSONALITYID, "CUsbSession::GetCurrentPersonalityId;currentPersonalityId=%d", currentPersonalityId ); TPckgC pckg(currentPersonalityId); return aMessage.Write(0, pckg); } @@ -1251,10 +1293,11 @@ */ TInt CUsbSession::GetSupportedClasses(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDCLASSES_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT ); return KErrNotSupported; } @@ -1266,7 +1309,11 @@ TInt personalityCount = personalities.Count(); for (TInt i = 0; i < personalityCount; i++) { - __ASSERT_ALWAYS(personalities[i] != NULL, _USB_PANIC(KUsbSvrPncCat, ENullPersonalityPointer)); + if(personalities[i] == NULL) + { + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES, "CUsbSession::GetSupportedClasses;ENullPersonalityPointer=%d", ENullPersonalityPointer ); + User::Panic(KUsbSvrPncCat, ENullPersonalityPointer); + } if (aMessage.Int0() == personalities[i]->PersonalityId()) { classUids[0] = personalities[i]->SupportedClasses().Count(); @@ -1274,11 +1321,13 @@ { if (j < KUsbMaxSupportedClasses + 1) { - classUids[j] = personalities[i]->SupportedClasses()[j - 1].iUid; - LOGTEXT3(_L8("\tclassUids[%d] = %d"), j, classUids[j]); + classUids[j] = personalities[i]->SupportedClasses()[j - 1].iClassUid.iUid; + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES_DUP1, "CUsbSession::GetSupportedClasses;classUids[%d] = ", j ); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDCLASSES_DUP2, "%d", classUids[j] ); } else { + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP1 ); return KErrTooBig; } } @@ -1289,6 +1338,7 @@ if (classUids[0] == 0) { // No supported classes are found + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP2 ); return KErrNotSupported; } @@ -1303,6 +1353,7 @@ } delete buf; + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDCLASSES_EXIT_DUP3 ); return ret; } @@ -1315,10 +1366,11 @@ */ TInt CUsbSession::GetPersonalityIds(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETPERSONALITYIDS_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYIDS_EXIT ); return KErrNotSupported; } @@ -1329,7 +1381,11 @@ TInt personalityCount = personalities.Count(); for (TInt i = 0; i < personalityCount; ++i) { - __ASSERT_ALWAYS(personalities[i] != NULL, _USB_PANIC(KUsbSvrPncCat, ENullPersonalityPointer)); + if(personalities[i] == NULL) + { + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETPERSONALITYIDS, "CUsbSession::GetPersonalityIds;Panic reason=%d", ENullPersonalityPointer ); + User::Panic(KUsbSvrPncCat, ENullPersonalityPointer); + } personalityIds[i + 1] = personalities[i]->PersonalityId(); } personalityIds[0] = personalityCount; @@ -1345,6 +1401,7 @@ } delete buf; + OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYIDS_EXIT_DUP1 ); return ret; } @@ -1357,10 +1414,11 @@ */ TInt CUsbSession::GetDescription(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETDESCRIPTION_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_GETDESCRIPTION_EXIT ); return KErrNotSupported; } @@ -1372,39 +1430,10 @@ } // We should never reach here + OstTraceFunctionExit0( CUSBSESSION_GETDESCRIPTION_EXIT_DUP1 ); return KErrNotSupported; } -/** - * Gets personality detailed description - * - * @internalComponent - * @param aMessage Message received from the client - * @return Any error that occurred or KErrNone - */ -TInt CUsbSession::GetDetailedDescription(const RMessage2& aMessage) - { - LOG_FUNC - - if (!iPersonalityCfged) - { - return KErrNotSupported; - } - - TInt personalityId = aMessage.Int0(); - const CPersonality* personality = iUsbServer->Device().GetPersonality(personalityId); - if (personality) - { - if(personality->Version() < EUsbManagerResourceVersionTwo) - { - return KErrNotFound; - } - return aMessage.Write(1, *(personality->DetailedDescription())); - } - - // We should never reach here - return KErrNotSupported; - } /** * Gets personality property @@ -1415,10 +1444,11 @@ */ TInt CUsbSession::GetPersonalityProperty(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETPERSONALITYPROPERTY_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYPROPERTY_EXIT ); return KErrNotSupported; } @@ -1426,14 +1456,11 @@ const CPersonality* personality = iUsbServer->Device().GetPersonality(personalityId); if (personality) { - if(personality->Version() < EUsbManagerResourceVersionThree) - { - return KErrNotFound; - } TPckg pckg(personality->Property()); return aMessage.Write(1, pckg); } + OstTraceFunctionExit0( CUSBSESSION_GETPERSONALITYPROPERTY_EXIT_DUP2 ); return KErrNotSupported; } @@ -1446,10 +1473,10 @@ */ TInt CUsbSession::ClassSupported(const RMessage2& aMessage) { - LOG_FUNC - + OstTraceFunctionEntry0( CUSBSESSION_CLASSSUPPORTED_ENTRY ); if (!iPersonalityCfged) { + OstTraceFunctionExit0( CUSBSESSION_CLASSSUPPORTED_EXIT ); return KErrNotSupported; } @@ -1459,12 +1486,13 @@ const CPersonality* personality = iUsbServer->Device().GetPersonality(personalityId); if (personality) { - isSupported = (personality->ClassSupported(classUid) != KErrNotFound); + isSupported = personality->ClassSupported(classUid); TPckg pkg2(isSupported); return aMessage.Write(2, pkg2); } // We should never reach here + OstTraceFunctionExit0( CUSBSESSION_CLASSSUPPORTED_EXIT_DUP1 ); return KErrNotSupported; } @@ -1478,12 +1506,12 @@ */ TInt CUsbSession::SetCtlSessionMode(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_SETCTLSESSIONMODE_ENTRY ); TInt ret = KErrNone; TBool value = (TBool)aMessage.Int0(); - LOGTEXT2(_L8("\tSetting = %d"), static_cast(value)); + OstTrace1( TRACE_NORMAL, CUSBSESSION_SETCTLSESSIONMODE, "CUsbSession::SetCtlSessionMode;Setting = %d", static_cast(value) ); // Verify if this is the same session which set the value before if ( iCtlSession && (iCtlSession != this) ) @@ -1505,6 +1533,7 @@ } } + OstTraceFunctionExit0( CUSBSESSION_SETCTLSESSIONMODE_EXIT ); return ret; } @@ -1517,7 +1546,7 @@ */ TInt CUsbSession::BusRequest() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_BUSREQUEST_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1529,6 +1558,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_BUSREQUEST_EXIT ); return ret; } @@ -1543,7 +1573,7 @@ */ TInt CUsbSession::BusRespondSrp() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_BUSRESPONDSRP_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1555,6 +1585,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_BUSRESPONDSRP_EXIT ); return ret; } @@ -1568,7 +1599,7 @@ */ TInt CUsbSession::BusClearError() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_BUSCLEARERROR_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1580,6 +1611,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_BUSCLEARERROR_EXIT ); return ret; } @@ -1592,7 +1624,7 @@ */ TInt CUsbSession::BusDrop() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_BUSDROP_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1604,6 +1636,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_BUSDROP_EXIT ); return ret; } @@ -1616,7 +1649,7 @@ */ TInt CUsbSession::EnableFunctionDriverLoading() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_ENABLEFUNCTIONDRIVERLOADING_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1628,6 +1661,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_ENABLEFUNCTIONDRIVERLOADING_EXIT ); return ret; } @@ -1640,7 +1674,7 @@ */ TInt CUsbSession::DisableFunctionDriverLoading() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_DISABLEFUNCTIONDRIVERLOADING_ENTRY ); TInt ret = KErrNone; if ( iSessionCtlMode ) @@ -1652,6 +1686,7 @@ ret = KErrAccessDenied; } + OstTraceFunctionExit0( CUSBSESSION_DISABLEFUNCTIONDRIVERLOADING_EXIT ); return ret; } @@ -1664,8 +1699,9 @@ */ TInt CUsbSession::GetSupportedLanguages(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDLANGUAGES_ENTRY ); TRAPD(err, GetSupportedLanguagesL(aMessage)); + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDLANGUAGES_EXIT ); return err; } @@ -1678,11 +1714,10 @@ */ TInt CUsbSession::GetSupportedLanguagesL(const RMessage2& aMessage) { - LOG_FUNC - + OstTraceFunctionEntry0( CUSBSESSION_GETSUPPORTEDLANGUAGESL_ENTRY ); const TUint deviceId = aMessage.Int0(); - LOGTEXT2(_L8("\tdeviceId = %d"), deviceId); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL, "CUsbSession::GetSupportedLanguagesL;deviceId=%d", deviceId ); RArray langIds; CleanupClosePushL(langIds); @@ -1691,7 +1726,7 @@ if (ret == KErrNone) { const TUint count = langIds.Count(); - LOGTEXT2(_L8("\tcount = %d"), count); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL_DUP1, "CUsbSession::GetSupportedLanguagesL;count=%d", count ); // Set error code if there is no languages or there are too many if ( count == 0 ) @@ -1717,7 +1752,7 @@ for ( TUint ii = 0 ; ii < count; ++ii ) { buf.Append((TUint8*)&(langIds[ii]), sizeof(TUint)); - LOGTEXT3(_L8("Append langID[%d] = %d"),ii,langIds[ii]); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETSUPPORTEDLANGUAGESL_DUP2, "CUsbSession::GetSupportedLanguagesL;Append langID[%d] = %d", ii, langIds[ii] ); } // Write back to the client. @@ -1728,6 +1763,7 @@ CleanupStack::PopAndDestroy(); + OstTraceFunctionExit0( CUSBSESSION_GETSUPPORTEDLANGUAGESL_EXIT ); return ret; } @@ -1740,20 +1776,21 @@ */ TInt CUsbSession::GetManufacturerStringDescriptor(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_ENTRY ); const TUint deviceId = aMessage.Int0(); const TUint langId = aMessage.Int1(); - LOGTEXT3(_L8("\tdeviceId = %d, langId = %d"), deviceId, langId); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR, "CUsbSession::GetManufacturerStringDescriptor;langId=%d;deviceId=%d", langId, deviceId ); TName string; TInt ret = iUsbServer->Host().GetManufacturerStringDescriptor(deviceId,langId,string); if (ret == KErrNone) { - LOGTEXT2(_L("\tstring = \"%S\""), &string); + OstTraceExt1( TRACE_NORMAL, CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_DUP1, "CUsbSession::GetManufacturerStringDescriptor;string = \"%S\"", string ); ret = aMessage.Write(2, string); } + OstTraceFunctionExit0( CUSBSESSION_GETMANUFACTURERSTRINGDESCRIPTOR_EXIT ); return ret; } @@ -1766,20 +1803,21 @@ */ TInt CUsbSession::GetProductStringDescriptor(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_ENTRY ); const TUint deviceId = aMessage.Int0(); const TUint langId = aMessage.Int1(); - LOGTEXT3(_L8("\tdeviceId = %d, langId = %d"), deviceId, langId); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR, "CUsbSession::GetProductStringDescriptor;deviceId=%d;langId=%d", deviceId, langId ); TName string; TInt ret = iUsbServer->Host().GetProductStringDescriptor(deviceId,langId,string); if (ret == KErrNone) { - LOGTEXT2(_L("\tstring = \"%S\""), &string); + OstTraceExt1( TRACE_NORMAL, CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_DUP1, "CUsbSession::GetProductStringDescriptor;string = \"%S\"", string ); ret = aMessage.Write(2, string); } + OstTraceFunctionExit0( CUSBSESSION_GETPRODUCTSTRINGDESCRIPTOR_EXIT ); return ret; } @@ -1792,10 +1830,10 @@ */ TInt CUsbSession::GetOtgDescriptor(const RMessage2& aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_GETOTGDESCRIPTOR_ENTRY ); const TUint deviceId = aMessage.Int0(); - LOGTEXT2(_L8("\tdeviceId = %d"), deviceId); + OstTrace1( TRACE_NORMAL, CUSBSESSION_GETOTGDESCRIPTOR, "CUsbSession::GetOtgDescriptor;deviceId=%d", deviceId ); TOtgDescriptor otgDescriptor; TInt ret = iUsbServer->Host().GetOtgDescriptor(deviceId, otgDescriptor); @@ -1805,6 +1843,7 @@ ret = aMessage.Write(1, buf); } + OstTraceFunctionExit0( CUSBSESSION_GETOTGDESCRIPTOR_EXIT ); return ret; } @@ -1822,10 +1861,11 @@ */ TInt CUsbSession::RegisterHostObserver(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_REGISTERHOSTOBSERVER_ENTRY ); if (iHostEventObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_REGISTERHOSTOBSERVER_EXIT ); return KErrInUse; } @@ -1837,7 +1877,7 @@ { // This is the first observer after c'tor or DeregisterObserver(), // so zap the device event queue. - LOGTEXT(_L8(" Reset OTG Host State Queue")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERHOSTOBSERVER, "CUsbSession::RegisterHostObserver; Reset OTG Host State Queue" ); iHostEventQueueHead = 0; iHostEventQueueTail = 0; iHostEventObserverQueueEvents = ETrue; @@ -1848,6 +1888,7 @@ UsbHostEventDequeue(); } + OstTraceFunctionExit0( CUSBSESSION_REGISTERHOSTOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -1859,13 +1900,13 @@ */ TInt CUsbSession::DeRegisterHostObserver() { - LOG_FUNC - + OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERHOSTOBSERVER_ENTRY ); if (!iHostEventObserverQueueEvents) { //Never register - LOGTEXT(_L8("iHostEventObserverQueueEvents is FALSE!")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_DEREGISTERHOSTOBSERVER, "CUsbSession::DeRegisterHostObserver;iHostEventObserverQueueEvents is FALSE!" ); + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERHOSTOBSERVER_EXIT ); return KErrNone; } @@ -1873,7 +1914,7 @@ { iHostEventObserverOutstanding = EFalse; iHostEventObserverMessage.Complete(KErrCancel); - LOGTEXT(_L8("iHostEventObserverMessage.Complete(KErrCancel);")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_DEREGISTERHOSTOBSERVER_DUP1, "CUsbSession::DeRegisterHostObserver;iHostEventObserverMessage.Complete(KErrCancel);" ); } // client doesn't need events queuing any more @@ -1882,6 +1923,7 @@ iHostEventQueueHead = 0; iHostEventQueueTail = 0; + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERHOSTOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -1899,10 +1941,11 @@ */ TInt CUsbSession::RegisterMsgObserver(const RMessage2& aMessage, TBool& aComplete) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_REGISTERMSGOBSERVER_ENTRY ); if (iMsgObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_REGISTERMSGOBSERVER_EXIT ); return KErrInUse; } @@ -1914,7 +1957,7 @@ { // This is the first observer after c'tor or DeregisterObserver(), // so zap the device event queue. - LOGTEXT(_L8(" Reset OTG Message Queue")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_REGISTERMSGOBSERVER, "CUsbSession::RegisterMsgObserver; Reset OTG Message Queue" ); iMsgQueueHead = 0; iMsgQueueTail = 0; iMsgObserverQueueEvents = ETrue; @@ -1925,6 +1968,7 @@ UsbMsgDequeue(); } + OstTraceFunctionExit0( CUSBSESSION_REGISTERMSGOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -1936,10 +1980,11 @@ */ TInt CUsbSession::DeRegisterMsgObserver() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_DEREGISTERMSGOBSERVER_ENTRY ); if (!iMsgObserverOutstanding) { + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERMSGOBSERVER_EXIT ); return KErrNone; } @@ -1949,6 +1994,7 @@ // client doesn't need events queuing any more iMsgObserverQueueEvents = EFalse; + OstTraceFunctionExit0( CUSBSESSION_DEREGISTERMSGOBSERVER_EXIT_DUP1 ); return KErrNone; } @@ -1962,7 +2008,7 @@ */ void CUsbSession::UsbOtgHostMessage(TInt aMessage) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBOTGHOSTMESSAGE_ENTRY ); // can we bypass the queue? if ((iMsgObserverOutstanding) && (iMsgQueueHead == iMsgQueueTail)) @@ -1980,12 +2026,12 @@ // add event to head of queue iMsgQueue[iMsgQueueHead] = aMessage; iMsgQueueHead = (iMsgQueueHead + 1) % KOtgHostMessageQueueSize; - LOGTEXT3(_L8("+++ CUsbSession::UsbOtgMessage() addqueue (%d, %d)"), iMsgQueueHead, - iMsgQueueTail); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBOTGHOSTMESSAGE, "CUsbSession::UsbOtgHostMessage; addqueue (%d, %d)", iMsgQueueHead, iMsgQueueTail ); // UsbMsgDequeueEvent() will read from queue when RegisterMsgObserver() // is next called. } + OstTraceFunctionExit0( CUSBSESSION_USBOTGHOSTMESSAGE_EXIT ); } /** @@ -1999,7 +2045,7 @@ */ void CUsbSession::UsbHostEvent(TDeviceEventInformation& aDevInfo) { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBHOSTEVENT_ENTRY ); // can we bypass the queue? if ((iHostEventObserverOutstanding) && (iHostEventQueueHead == iHostEventQueueTail)) @@ -2007,24 +2053,24 @@ iNotifiedHostState = aDevInfo; iHostEventObserverOutstanding = EFalse; - LOGTEXT(_L8("CUsbSession::UsbHostEvent() detected outstanding request")); + OstTrace0( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT, "CUsbSession::UsbHostEvent detected outstanding request" ); TPckg info(aDevInfo); const TInt err = iHostEventObserverMessage.Write(0, info); iHostEventObserverMessage.Complete(err); - LOGTEXT2(_L8("CUsbSession::UsbHostEvent() detects outstanding request: request is compeleted with %d"), err); + OstTrace1( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT_DUP1, "CUsbSession::UsbHostEvent; detects outstanding request: request is compeleted with %d", err ); } else if (iHostEventObserverQueueEvents) { // add dev info to head of queue iHostStateQueue[iHostEventQueueHead] = aDevInfo; iHostEventQueueHead = (iHostEventQueueHead + 1) % KDeviceStatesQueueSize; - LOGTEXT3(_L8("+++ CUsbSession::UsbHostEvent() addqueue (%d, %d)"), iHostEventQueueHead, - iHostEventQueueTail); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENT_DUP2, "CUsbSession::UsbHostEvent; addqueue (%d, %d)", iHostEventQueueHead, iHostEventQueueTail ); // UsbHostStateDequeueEvent() will read from queue when RegisterHostObserver() // is next called. } + OstTraceFunctionExit0( CUSBSESSION_USBHOSTEVENT_EXIT ); } /** @@ -2032,7 +2078,7 @@ */ void CUsbSession::UsbMsgDequeue() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBMSGDEQUEUE_ENTRY ); // Work our way through the queue, until we reach the end // OR we find an event the current observer wants. @@ -2046,12 +2092,13 @@ TPckg pckg(newMsg); iNotifiedMsg = newMsg; - LOGTEXT3(_L8(">>> dequeued event #%d (0x%x)"), iMsgQueueTail, newMsg); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBMSGDEQUEUE, "CUsbSession::UsbMsgDequeue;dequeued event #%d (0x%x)", iMsgQueueTail, newMsg ); iMsgObserverOutstanding = EFalse; const TInt err = iMsgObserverMessage.Write(0, pckg); iMsgObserverMessage.Complete(err); } + OstTraceFunctionExit0( CUSBSESSION_USBMSGDEQUEUE_EXIT ); } /** @@ -2059,7 +2106,7 @@ */ void CUsbSession::UsbHostEventDequeue() { - LOG_FUNC + OstTraceFunctionEntry0( CUSBSESSION_USBHOSTEVENTDEQUEUE_ENTRY ); // Work our way through the queue, until we reach the end // OR we find an event the current observer wants. @@ -2073,15 +2120,16 @@ // advance tail towards the head iHostEventQueueTail = (iHostEventQueueTail + 1) % KDeviceStatesQueueSize; - LOGTEXT3(_L8(">>> CUsbSession::UsbHostStateDequeueEvent() dequeued event #%d (0x%x)"), iHostEventQueueTail, newDevInfo.iEventType); + OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENTDEQUEUE, "CUsbSession::UsbHostEventDequeue; dequeued event #%d (0x%x)", iHostEventQueueTail, newDevInfo.iEventType ); TPckg info(newDevInfo); iHostEventObserverOutstanding = EFalse; const TInt err = iHostEventObserverMessage.Write(0, info); iHostEventObserverMessage.Complete(err); - LOGTEXT2(_L8("CUsbSession::UsbHostStateDequeueEvent() detects outstanding request: request is compeleted with %d"), err); + OstTrace1( TRACE_NORMAL, CUSBSESSION_USBHOSTEVENTDEQUEUE_DUP1, "CUsbSession::UsbHostStateDequeueEvent() detects outstanding request: request is compeleted with %d", err ); } + OstTraceFunctionExit0( CUSBSESSION_USBHOSTEVENTDEQUEUE_EXIT ); } TInt CUsbSession::RequestSession()