diff -r d3e8e7d462dd -r f92a4f87e424 usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp
--- a/usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp	Thu Jul 15 20:42:20 2010 +0300
+++ b/usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp	Tue Aug 31 17:01:47 2010 +0300
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-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"
@@ -18,16 +18,19 @@
 /** @file
 @internalComponent
 */
-
 #include "CUsbBatteryChargingPlugin.h"
-#include "chargingstates.h"
-#include <musbmanextensionpluginobserver.h>
-#include "cusbbatterycharginglicenseehooks.h"
-#include "reenumerator.h"
+#include <e32debug.h> 
+#include <e32def.h>
 #include <usb/usblogger.h>
 #include <e32property.h>
 #include <centralrepository.h>
 #include <usbotgdefs.h>
+#include <musbmanextensionpluginobserver.h>
+
+
+#include "chargingstates.h"
+#include "cusbbatterycharginglicenseehooks.h"
+#include "reenumerator.h"
 
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV          // For host OTG enabled charging plug-in 
 #include "idpinwatcher.h"
@@ -35,15 +38,15 @@
 #endif
 
 #include "vbuswatcher.h"
-#include <e32debug.h> 
-#include <e32def.h>
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "CUsbBatteryChargingPluginTraces.h"
+#endif
+
 
 static const TInt KUsbBatteryChargingConfigurationDescriptorCurrentOffset = 8; // see bMaxPower in section 9.6.3 of USB Spec 2.0
 static const TInt KUsbBatteryChargingCurrentRequestTimeout = 3000000; // 3 seconds
 
-#ifdef __FLOG_ACTIVE
-_LIT8(KLogComponent, "USBCHARGE");
-#endif
 
 /**
 Factory function.
@@ -63,8 +66,7 @@
 */
 CUsbBatteryChargingPlugin::~CUsbBatteryChargingPlugin()
     {
-    LOGTEXT(KNullDesC8);
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::~CUsbBatteryChargingPlugin this = [0x%08x]"), this);
+    OstTraceFunctionEntry1( REF_CUSBBATTERYCHARGINGPLUGIN_CUSBBATTERYCHARGINGPLUGIN_DES_ENTRY, this );
     
     iCurrentValues.Close();
     delete iDeviceReEnumerator;
@@ -99,7 +101,7 @@
 */
 void CUsbBatteryChargingPlugin::ConstructL()
     {
-    LOGTEXT(_L8(">>CUsbBatteryChargingPlugin::ConstructL"));
+   OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_ENTRY );
    
     // Create state objects
     iPluginStates[EPluginStateIdle] = 
@@ -137,7 +139,8 @@
         }
     else
         {
-        LEAVEL(err);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err );
+        User::Leave(err );
         }
 
     if(err == KErrNone || err == KErrAlreadyExists)
@@ -151,7 +154,8 @@
         static_cast<void> (RProperty::Delete (
                 KPropertyUidUsbBatteryChargingCategory,
                 KPropertyUidUsbBatteryChargingAvailableCurrent ));
-        LEAVEL(err);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP1, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err );
+        User::Leave(err);
         }
     
     err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
@@ -166,7 +170,8 @@
         static_cast<void> (RProperty::Delete (
                 KPropertyUidUsbBatteryChargingCategory,
                 KPropertyUidUsbBatteryChargingChargingCurrent ));
-        LEAVEL(err);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP2, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err );
+        User::Leave(err );
         }
         
     iRepositoryNotifier = CUsbChargingRepositoryNotifier::NewL (*this,
@@ -201,18 +206,18 @@
     else
         {
         iPluginState = EPluginStateBEndedCableNotPresent;
-        LOGTEXT2(_L8("PluginState => EPluginStateADevice(%d)"), iPluginState);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP3, "CUsbBatteryChargingPlugin::ConstructL;PluginState => EPluginStateADevice(%d)", iPluginState );
         }
 
     Observer().RegisterStateObserverL(*this);
 
     iLicenseeHooks = CUsbBatteryChargingLicenseeHooks::NewL();
-    LOGTEXT(_L8("Created licensee specific hooks"));
+    OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP4, "CUsbBatteryChargingPlugin::ConstructL;Created licensee specific hooks" );
     
     // Set initial recovery state to idle
     PushRecoverState(EPluginStateIdle);
     
-    LOGTEXT(_L8("<<CUsbBatteryChargingPlugin::ConstructL"));
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_EXIT );
     }
 
 // For host OTG enabled charging plug-in
@@ -247,21 +252,32 @@
 */
 void CUsbBatteryChargingPlugin::SetInitialConfigurationL()
     {
-    LOGTEXT(_L8("Setting Initial Configuration"));
+    OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;Setting Initial Configuration" );
     if (iCurrentValues.Count() > 0)
         {
+        TInt err;
         TInt configDescriptorSize = 0;
-        LEAVEIFERRORL(iLdd.GetConfigurationDescriptorSize(configDescriptorSize));
+        err = iLdd.GetConfigurationDescriptorSize(configDescriptorSize);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP1, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;iLdd.GetConfigurationDescriptorSize(configDescriptorSize) with error=%d", err );
+            User::Leave(err);
+            }
         HBufC8* configDescriptor = HBufC8::NewLC(configDescriptorSize);
         TPtr8 ptr(configDescriptor->Des());
 
-        LOGTEXT2(_L8("Getting Configuration Descriptor (size = %d)"),configDescriptorSize);
-        LEAVEIFERRORL(iLdd.GetConfigurationDescriptor(ptr));
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP2, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;Getting Configuration Descriptor (size = %d)", configDescriptorSize );
+        err = iLdd.GetConfigurationDescriptor(ptr);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP3, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;iLdd.GetConfigurationDescriptor(ptr) with error=%d", err );
+            User::Leave(err);
+            }
 
 // For host OTG enabled charging plug-in
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
         // Get first power to put in configurator
-        LOGTEXT(_L8("Checking IdPin state:"));
+        OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP4, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;Checking IdPin state:" );
         if(iIdPinState == EUsbBatteryChargingIdPinBRole)
 #else
         if (ETrue)
@@ -271,24 +287,29 @@
                 {
                 iCurrentIndexRequested = 0;
                 iRequestedCurrentValue = iCurrentValues[iCurrentIndexRequested];
-                LOGTEXT2(_L8("IdPin state is 0, current set to: %d"), iRequestedCurrentValue);
+                OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP5, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;IdPin state is 0, current set to: %d", iRequestedCurrentValue );
                 }
             else
                 {
-                LOGTEXT(_L8("No vailable current found !"));
+                OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP6, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;No vailable current found !" );
                 }
             }
         else
             {
             iRequestedCurrentValue = 0;
-            LOGTEXT(_L8("IdPin state is 1, current set to 0"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP7, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;IdPin state is 1, current set to 0" );
             }
 
         TUint oldCurrentValue = ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] << 1;
         ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] = (iRequestedCurrentValue >> 1);
 
-        LOGTEXT(_L8("Setting Updated Configuration Descriptor"));
-        LEAVEIFERRORL(iLdd.SetConfigurationDescriptor(ptr));
+        OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP8, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;Setting Updated Configuration Descriptor" );
+        err = iLdd.SetConfigurationDescriptor(ptr);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETINITIALCONFIGURATIONL_DUP9, "CUsbBatteryChargingPlugin::SetInitialConfigurationL;iLdd.SetConfigurationDescriptor(ptr) with error=%d", err );
+            User::Leave(err);
+            }
 
         CleanupStack::PopAndDestroy(configDescriptor); 
         }
@@ -297,19 +318,19 @@
 
 TAny* CUsbBatteryChargingPlugin::GetInterface(TUid aUid)
     {
-    LOGTEXT(KNullDesC8);
-    LOGTEXT3(_L8(">>CUsbBatteryChargingPlugin::GetInterface this = [0x%08x], aUid = 0x%08x"), this, aUid);
+    OstTrace1( TRACE_FLOW, REF_CUSBBATTERYCHARGINGPLUGIN_GETINTERFACE, "CUsbBatteryChargingPlugin::GetInterface;this = [0x%08x]", this );
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_GETINTERFACE_DUP1, "CUsbBatteryChargingPlugin::GetInterface;aUid = 0x%08x", aUid.iUid );
     (void)aUid;
 
     TAny* ret = NULL;
 
-    LOGTEXT2(_L8("<<CUsbBatteryChargingPlugin::GetInterface ret = [0x%08x]"), ret);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_GETINTERFACE_DUP2, "CUsbBatteryChargingPlugin::GetInterface;ret = [0x%08x]", ret );
     return ret;
     }
 
 void CUsbBatteryChargingPlugin::Panic(TUsbBatteryChargingPanic aPanic)
     {
-    LOGTEXT2(_L8("*** CUsbBatteryChargingPlugin::Panic(%d) ***"),aPanic);
+    OstTrace1( TRACE_FATAL, REF_CUSBBATTERYCHARGINGPLUGIN_PANIC, "CUsbBatteryChargingPlugin::Panic;*** CUsbBatteryChargingPlugin::Panic(%d) ***", aPanic );
     _LIT(KUsbChargingPanic,"USB Charging");
     User::Panic(KUsbChargingPanic, aPanic);
     }
@@ -321,7 +342,7 @@
 
 void CUsbBatteryChargingPlugin::PushRecoverState(TUsbChargingPluginState aRecoverState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_PUSHRECOVERSTATE_ENTRY );
 
     if((aRecoverState == EPluginStateIdle)||
        (aRecoverState == EPluginStateIdleNegotiated) ||
@@ -330,22 +351,24 @@
         {
         iPluginStateToRecovery = aRecoverState;
         }
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_PUSHRECOVERSTATE_EXIT );
     }
 
 TUsbChargingPluginState CUsbBatteryChargingPlugin::PopRecoverState()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_POPRECOVERSTATE_ENTRY );
     
     SetState(iPluginStateToRecovery);
     
     iPluginStateToRecovery = EPluginStateIdle;
     
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_POPRECOVERSTATE_EXIT );
     return iPluginStateToRecovery;
     }
 
 TUsbChargingPluginState CUsbBatteryChargingPlugin::SetState(TUsbChargingPluginState aState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_SETSTATE_ENTRY );
 
     switch (aState)
         {
@@ -371,22 +394,23 @@
             iPluginState = EPluginStateIdle;
             iCurrentState = iPluginStates[EPluginStateIdle];
     
-            LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetState: Invalid new state: aState = %d"), aState);
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETSTATE, "CUsbBatteryChargingPlugin::SetState;Invalid new state: aState = %d", aState );
             
             Panic(EUsbBatteryChargingPanicUnexpectedPluginState);
         }
     iPluginState = aState;
     
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetState, New state: aState = %d"), aState);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETSTATE_DUP1, "CUsbBatteryChargingPlugin::SetState;New state: aState=%d", aState );
     
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_SETSTATE_EXIT );
     return iPluginState;
     }
 
 void CUsbBatteryChargingPlugin::NegotiateChargingCurrent()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATECHARGINGCURRENT_ENTRY );
 
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::StartNegotiation,  iDeviceState = %d"), iDeviceState);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATECHARGINGCURRENT, "CUsbBatteryChargingPlugin::NegotiateChargingCurrent;iDeviceState=%d", iDeviceState );
     TRAPD(result, NegotiateNextCurrentValueL());
     if(result == KErrNone)
         {
@@ -394,35 +418,39 @@
         }
     else
         {
-        LOGTEXT2(_L8("Negotiation call failed, iVBusState = 1: result = %d"), result);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATECHARGINGCURRENT_DUP1, "CUsbBatteryChargingPlugin::NegotiateChargingCurrent;Negotiation call failed, iVBusState = 1: result = %d", result );
         }
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATECHARGINGCURRENT_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::UsbDeviceStateChange(TInt aLastError,
         TUsbDeviceState aOldState, TUsbDeviceState aNewState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_USBDEVICESTATECHANGE_ENTRY );
     
     iCurrentState->UsbDeviceStateChange(aLastError, aOldState, aNewState);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_USBDEVICESTATECHANGE_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::HandleRepositoryValueChangedL(const TUid& aRepository, TUint aId, TInt aVal)
     {
-    LOG_FUNC    
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_HANDLEREPOSITORYVALUECHANGEDL_ENTRY );
 
     iCurrentState->HandleRepositoryValueChangedL(aRepository, aId, aVal);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_HANDLEREPOSITORYVALUECHANGEDL_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::DeviceStateTimeout()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_DEVICESTATETIMEOUT_ENTRY );
         
     iCurrentState->DeviceStateTimeout();
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_DEVICESTATETIMEOUT_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::NegotiateNextCurrentValueL()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATENEXTCURRENTVALUEL_ENTRY );
 
     iDeviceStateTimer->Cancel();
     TUint newCurrent = 0;
@@ -454,18 +482,19 @@
     RequestCurrentL(newCurrent);
     iRequestedCurrentValue = newCurrent;
     iPluginState = EPluginStateCurrentNegotiating;
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_NEGOTIATENEXTCURRENTVALUEL_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::ResetPlugin()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_RESETPLUGIN_ENTRY );
     
     if((iPluginState != EPluginStateIdle))
         {
         iDeviceStateTimer->Cancel(); // doesn't matter if not running
         iPluginState = EPluginStateIdle;
         iPluginStateToRecovery = EPluginStateIdle;
-        LOGTEXT2(_L8("PluginState => EPluginStateIdle(%d)"),iPluginState);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_RESETPLUGIN, "CUsbBatteryChargingPlugin::ResetPlugin;PluginState => EPluginStateIdle(%d)", iPluginState );
 
         iRequestedCurrentValue = 0;
         iCurrentIndexRequested = 0;
@@ -473,52 +502,70 @@
         SetNegotiatedCurrent(0);
         TRAP_IGNORE(SetInitialConfigurationL());
         }
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_RESETPLUGIN_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::RequestCurrentL(TUint aMilliAmps)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_ENTRY );
     
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::RequestCurrent aMilliAmps = %d"), aMilliAmps);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL, "CUsbBatteryChargingPlugin::RequestCurrentL;aMilliAmps=%u", aMilliAmps );
 
     if((EPluginStateCurrentNegotiating == iPluginState) && (iRequestedCurrentValue != aMilliAmps))
         {
+        TInt err;
         TInt configDescriptorSize = 0;
-        LEAVEIFERRORL(iLdd.GetConfigurationDescriptorSize(configDescriptorSize));
+        err = iLdd.GetConfigurationDescriptorSize(configDescriptorSize);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP1, "CUsbBatteryChargingPlugin::RequestCurrentL;iLdd.GetConfigurationDescriptorSize(configDescriptorSize) with error=%d", err );
+            User::Leave(err);
+            }
         HBufC8* configDescriptor = HBufC8::NewLC(configDescriptorSize);
         TPtr8 ptr(configDescriptor->Des());
 
-        LOGTEXT2(_L8("Getting Configuration Descriptor (size = %d)"),configDescriptorSize);
-        LEAVEIFERRORL(iLdd.GetConfigurationDescriptor(ptr));
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP2, "CUsbBatteryChargingPlugin::RequestCurrentL;Getting Configuration Descriptor (size = %d)", configDescriptorSize );
+        err = iLdd.GetConfigurationDescriptor(ptr);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP3, "CUsbBatteryChargingPlugin::RequestCurrentL;iLdd.GetConfigurationDescriptor(ptr) with error=%d", err );
+            User::Leave(err);
+            }
 
         // set bMaxPower field. One unit = 2mA, so need to halve aMilliAmps.
-        LOGTEXT3(_L8("Setting bMaxPower to %d mA ( = %d x 2mA units)"),aMilliAmps, (aMilliAmps >> 1));
+        OstTraceExt2( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP4, "CUsbBatteryChargingPlugin::RequestCurrentL;Setting bMaxPower to %u mA ( = %u x 2mA units)", aMilliAmps, aMilliAmps >> 1 );
         TUint oldCurrentValue = ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] << 1;
-        LOGTEXT2(_L8("(old value was %d mA)"), oldCurrentValue);
+        OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP5, "CUsbBatteryChargingPlugin::RequestCurrentL;(old value was %u mA)", oldCurrentValue );
 
         //since the device will force reEnumeration if the value is odd
         aMilliAmps = aMilliAmps & 0xFFFE;    
     
         // to negotiate a new current value, ReEnumerate is needed
-        LOGTEXT(_L8("Forcing ReEnumeration"));
+        OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP6, "CUsbBatteryChargingPlugin::RequestCurrentL;Forcing ReEnumeration" );
         ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] = (aMilliAmps >> 1);
-        LOGTEXT(_L8("Setting Updated Configuration Descriptor"));
-        LEAVEIFERRORL(iLdd.SetConfigurationDescriptor(ptr));
-        LOGTEXT(_L8("Triggering Re-enumeration"));
+        OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP7, "CUsbBatteryChargingPlugin::RequestCurrentL;Setting Updated Configuration Descriptor" );
+        err = iLdd.SetConfigurationDescriptor(ptr);
+        if(err < 0)
+            {
+            OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP8, "CUsbBatteryChargingPlugin::RequestCurrentL;iLdd.SetConfigurationDescriptor(ptr) with err=%d", err );
+            User::Leave(err);
+            }
+        OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP9, "CUsbBatteryChargingPlugin::RequestCurrentL;Triggering Re-enumeration" );
         iDeviceReEnumerator->ReEnumerate();
         
         CleanupStack::PopAndDestroy(configDescriptor); // configDescriptor
         }    
     
     // Always issue a timer as a watchdog to monitor the request progress
-    LOGTEXT2(_L8("Starting timer: %d"), User::NTickCount());
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_DUP10, "CUsbBatteryChargingPlugin::RequestCurrentL;Starting timer: %d", User::NTickCount() );
     iDeviceStateTimer->Cancel();
     iDeviceStateTimer->Start(TTimeIntervalMicroSeconds32(KUsbBatteryChargingCurrentRequestTimeout));
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_REQUESTCURRENTL_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::ReadCurrentRequestValuesL()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_READCURRENTREQUESTVALUESL_ENTRY );
     
     CRepository* repository = CRepository::NewLC(KUsbBatteryChargingCentralRepositoryUid);
 
@@ -531,26 +578,27 @@
         TInt value;
         repository->Get(KUsbBatteryChargingCurrentValuesOffset + i, value);
         iCurrentValues.Append(static_cast<TUint>(value));
-        LOGTEXT3(_L8("CurrentValue %d = %dmA"),i,value);
+        OstTraceExt2( TRACE_FLOW, REF_CUSBBATTERYCHARGINGPLUGIN_READCURRENTREQUESTVALUESL, "CUsbBatteryChargingPlugin::ReadCurrentRequestValuesL;CurrentValue %d = %dmA", i, value );
         }
 
     CleanupStack::PopAndDestroy(repository);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_READCURRENTREQUESTVALUESL_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::StartCharging(TUint aMilliAmps)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_ENTRY );
     
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::StartCharging aMilliAmps = %d"), aMilliAmps);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING, "CUsbBatteryChargingPlugin::StartCharging;aMilliAmps=%u", aMilliAmps );
     
     // do licensee specific functionality (if any)
     iLicenseeHooks->StartCharging(aMilliAmps);
 
-#ifdef __FLOG_ACTIVE
+#ifdef _DEBUG
     TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                 KPropertyUidUsbBatteryChargingChargingCurrent,
                             aMilliAmps);
-    LOGTEXT3(_L8("Set P&S current = %dmA - err = %d"),aMilliAmps,err);
+    OstTraceExt2( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_DUP1, "CUsbBatteryChargingPlugin::StartCharging;Set P&S current = %umA - err = %d", aMilliAmps, err );
 #else
     (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                 KPropertyUidUsbBatteryChargingChargingCurrent,
@@ -558,91 +606,95 @@
 #endif
 
     SetState(EPluginStateCharging);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::StopCharging()
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_STOPCHARGING_ENTRY );
     
     // do licensee specific functionality (if any)
     iLicenseeHooks->StopCharging();
 
-#ifdef __FLOG_ACTIVE
+#ifdef _DEBUG
     TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                                     KPropertyUidUsbBatteryChargingChargingCurrent,
                                     0);
-    LOGTEXT2(_L8("Set P&S current = 0mA - err = %d"),err);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_STOPCHARGING, "CUsbBatteryChargingPlugin::StopCharging;Set P&S current = 0mA - err = %d", err );
 #else
     (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                                     KPropertyUidUsbBatteryChargingChargingCurrent,
                                     0);
 #endif
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_STOPCHARGING_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::SetNegotiatedCurrent(TUint aMilliAmps)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT_ENTRY );
     
-    LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetNegotiatedCurrent aMilliAmps = %d"), aMilliAmps);
+    OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT, "CUsbBatteryChargingPlugin::SetNegotiatedCurrent;aMilliAmps=%u", aMilliAmps );
 
     // Ignore errors - not much we can do if it fails
-#ifdef __FLOG_ACTIVE
+#ifdef _DEBUG
     TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                                     KPropertyUidUsbBatteryChargingAvailableCurrent,
                                     aMilliAmps);
-    LOGTEXT3(_L8("Set P&S current = %dmA - err = %d"),aMilliAmps,err);
+    OstTraceExt2( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT_DUP1, "CUsbBatteryChargingPlugin::SetNegotiatedCurrent;Set P&S current = %umA - err = %d", aMilliAmps, err );
 #else
     (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
                                     KPropertyUidUsbBatteryChargingAvailableCurrent,
                                     aMilliAmps);
 #endif
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT_EXIT );
     }
 
 
-#ifndef __FLOG_ACTIVE
+#ifndef _DEBUG
 void CUsbBatteryChargingPlugin::LogStateText(TUsbDeviceState /*aState*/)
     {
-    LOG_FUNC
     }
 #else
 void CUsbBatteryChargingPlugin::LogStateText(TUsbDeviceState aState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_ENTRY );
     
     switch (aState)
         {
         case EUsbDeviceStateUndefined:
-            LOGTEXT(_L8(" ***** UNDEFINED *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT, "CUsbBatteryChargingPlugin::LogStateText; ***** UNDEFINED *****" );
             break;
         case EUsbDeviceStateDefault:
-            LOGTEXT(_L8(" ***** DEFAULT *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP1, "CUsbBatteryChargingPlugin::LogStateText; ***** DEFAULT *****" );
             break;
         case EUsbDeviceStateAttached:
-            LOGTEXT(_L8(" ***** ATTACHED *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP2, "CUsbBatteryChargingPlugin::LogStateText; ***** ATTACHED *****" );
             break;
         case EUsbDeviceStatePowered:
-            LOGTEXT(_L8(" ***** POWERED *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP3, "CUsbBatteryChargingPlugin::LogStateText; ***** POWERED *****" );
             break;
         case EUsbDeviceStateConfigured:
-            LOGTEXT(_L8(" ***** CONFIGURED *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP4, "CUsbBatteryChargingPlugin::LogStateText; ***** CONFIGURED *****" );
             break;
         case EUsbDeviceStateAddress:
-            LOGTEXT(_L8(" ***** ADDRESS *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP5, "CUsbBatteryChargingPlugin::LogStateText; ***** ADDRESS *****" );
             break;
         case EUsbDeviceStateSuspended:
-            LOGTEXT(_L8(" ***** SUSPENDED *****"));
+            OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_DUP6, "CUsbBatteryChargingPlugin::LogStateText; ***** SUSPENDED *****" );
             break;
         default:
             break;
         }
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_LOGSTATETEXT_EXIT );
     }
 #endif
 
 void CUsbBatteryChargingPlugin::MpsoVBusStateChanged(TInt aNewState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOVBUSSTATECHANGED_ENTRY );
     
     iCurrentState->MpsoVBusStateChanged(aNewState);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOVBUSSTATECHANGED_EXIT );
     }
 
 
@@ -650,15 +702,17 @@
 #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
 void CUsbBatteryChargingPlugin::MpsoIdPinStateChanged(TInt aValue)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOIDPINSTATECHANGED_ENTRY );
     
     iCurrentState->MpsoIdPinStateChanged(aValue);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOIDPINSTATECHANGED_EXIT );
     }
 
 void CUsbBatteryChargingPlugin::MpsoOtgStateChangedL(TUsbOtgState aNewState)
     {
-    LOG_FUNC
+    OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOOTGSTATECHANGEDL_ENTRY );
 
     iCurrentState->MpsoOtgStateChangedL(aNewState);
+    OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOOTGSTATECHANGEDL_EXIT );
     }
 #endif