--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp Tue Feb 02 02:02:59 2010 +0200
@@ -0,0 +1,664 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+/** @file
+@internalComponent
+*/
+
+#include "CUsbBatteryChargingPlugin.h"
+#include "chargingstates.h"
+#include <musbmanextensionpluginobserver.h>
+#include "cusbbatterycharginglicenseehooks.h"
+#include "reenumerator.h"
+#include <usb/usblogger.h>
+#include <e32property.h>
+#include <centralrepository.h>
+#include <usbotgdefs.h>
+
+#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // For host OTG enabled charging plug-in
+#include "idpinwatcher.h"
+#include "otgstatewatcher.h"
+#endif
+
+#include "vbuswatcher.h"
+#include <e32debug.h>
+#include <e32def.h>
+
+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.
+@return Ownership of a new CUsbBatteryChargingPlugin.
+*/
+CUsbBatteryChargingPlugin* CUsbBatteryChargingPlugin::NewL(MUsbmanExtensionPluginObserver& aObserver)
+ {
+ CUsbBatteryChargingPlugin* self = new(ELeave) CUsbBatteryChargingPlugin(aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+Destructor.
+*/
+CUsbBatteryChargingPlugin::~CUsbBatteryChargingPlugin()
+ {
+ LOGTEXT(KNullDesC8);
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::~CUsbBatteryChargingPlugin this = [0x%08x]"), this);
+
+ iCurrentValues.Close();
+ delete iDeviceReEnumerator;
+ delete iDeviceStateTimer;
+ delete iRepositoryNotifier;
+ delete iLicenseeHooks;
+
+// For host OTG enabled charging plug-in
+#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
+ delete iIdPinWatcher;
+ delete iOtgStateWatcher;
+#endif
+
+ delete iVBusWatcher;
+ for (TInt index = 0; index < EPluginStateCount; index ++)
+ {
+ delete iPluginStates[index];
+ iPluginStates[index] = NULL;
+ }
+ }
+
+/**
+Constructor.
+*/
+CUsbBatteryChargingPlugin::CUsbBatteryChargingPlugin(MUsbmanExtensionPluginObserver& aObserver)
+: CUsbmanExtensionPlugin(aObserver) , iLdd(Observer().DevUsbcClient())
+ {
+ }
+
+/**
+2nd-phase construction.
+*/
+void CUsbBatteryChargingPlugin::ConstructL()
+ {
+ LOGTEXT(_L8(">>CUsbBatteryChargingPlugin::ConstructL"));
+
+ // Create state objects
+ iPluginStates[EPluginStateIdle] =
+ new (ELeave) TUsbBatteryChargingPluginStateIdle(*this);
+ iPluginStates[EPluginStateCurrentNegotiating] =
+ new (ELeave) TUsbBatteryChargingPluginStateCurrentNegotiating(*this);
+ iPluginStates[EPluginStateCharging] =
+ new (ELeave) TUsbBatteryChargingPluginStateCharging(*this);
+ iPluginStates[EPluginStateNoValidCurrent] =
+ new (ELeave) TUsbBatteryChargingPluginStateNoValidCurrent(*this);
+ iPluginStates[EPluginStateIdleNegotiated] =
+ new (ELeave) TUsbBatteryChargingPluginStateIdleNegotiated(*this);
+ iPluginStates[EPluginStateUserDisabled] =
+ new (ELeave) TUsbBatteryChargingPluginStateUserDisabled(*this);
+ iPluginStates[EPluginStateBEndedCableNotPresent] =
+ new (ELeave) TUsbBatteryChargingPluginStateBEndedCableNotPresent(*this);
+
+ // Set initial state to idle
+ SetState(EPluginStateIdle);
+
+ TInt err = RProperty::Define(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent,
+ RProperty::EInt,
+ ECapabilityReadDeviceData,
+ ECapabilityCommDD);
+
+ if(err == KErrNone || err == KErrAlreadyExists)
+ {
+
+ err = RProperty::Define(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ RProperty::EInt,
+ ECapabilityReadDeviceData,
+ ECapabilityCommDD);
+ }
+ else
+ {
+ LEAVEL(err);
+ }
+
+ if(err == KErrNone || err == KErrAlreadyExists)
+ {
+ err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent,
+ 0);
+ }
+ else
+ {
+ static_cast<void> (RProperty::Delete (
+ KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent ));
+ LEAVEL(err);
+ }
+
+ err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ 0);
+
+ if(err != KErrNone)
+ {
+ static_cast<void> (RProperty::Delete (
+ KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent ));
+ static_cast<void> (RProperty::Delete (
+ KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent ));
+ LEAVEL(err);
+ }
+
+ iRepositoryNotifier = CUsbChargingRepositoryNotifier::NewL (*this,
+ KUsbBatteryChargingCentralRepositoryUid,
+ KUsbBatteryChargingKeyEnabledUserSetting );
+ iDeviceStateTimer = CUsbChargingDeviceStateTimer::NewL(*this);
+
+ iDeviceReEnumerator = CUsbChargingReEnumerator::NewL(iLdd);
+
+ iPluginState = EPluginStateIdle;
+ iPluginStateToRecovery = EPluginStateIdle;
+ ReadCurrentRequestValuesL();
+ iVBusWatcher = CVBusWatcher::NewL(this);
+ iVBusState = iVBusWatcher->VBusState();
+
+// For host OTG enabled charging plug-in
+#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
+ iOtgStateWatcher = COtgStateWatcher::NewL(this);
+ iOtgState = iOtgStateWatcher->OtgState();
+ iIdPinWatcher = CIdPinWatcher::NewL(this);
+ TInt value = iIdPinWatcher->IdPinValue();
+ iIdPinState = iIdPinWatcher->IdPinValue();
+ if (iIdPinState == EUsbBatteryChargingIdPinBRole)
+#else
+ if (ETrue)
+#endif
+ {
+#if !defined(__WINS__) && !defined(__CHARGING_PLUGIN_TEST_CODE__)
+ SetInitialConfigurationL();
+#endif
+ }
+ else
+ {
+ iPluginState = EPluginStateBEndedCableNotPresent;
+ LOGTEXT2(_L8("PluginState => EPluginStateADevice(%d)"), iPluginState);
+ }
+
+ Observer().RegisterStateObserverL(*this);
+
+ iLicenseeHooks = CUsbBatteryChargingLicenseeHooks::NewL();
+ LOGTEXT(_L8("Created licensee specific hooks"));
+
+ // Set initial recovery state to idle
+ PushRecoverState(EPluginStateIdle);
+
+ LOGTEXT(_L8("<<CUsbBatteryChargingPlugin::ConstructL"));
+ }
+
+// For host OTG enabled charging plug-in
+TBool CUsbBatteryChargingPlugin::IsUsbChargingPossible()
+ {
+#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
+ // VBus is off, so there is no way to do charging
+ if (0 == iVBusState)
+ {
+ return EFalse;
+ }
+
+ // 'A' end cable connected. I'm the power supplier, with no way to charge myself :-)
+ if (EUsbBatteryChargingIdPinARole == iIdPinState)
+ {
+ return EFalse;
+ }
+
+ // BHost charging is disabled
+ if (EUsbOtgStateBHost == iOtgState)
+ {
+ return EFalse;
+ }
+
+ return ETrue;
+#else
+ return ETrue;
+#endif
+ }
+/**
+ Set first power to request
+*/
+void CUsbBatteryChargingPlugin::SetInitialConfigurationL()
+ {
+ LOGTEXT(_L8("Setting Initial Configuration"));
+ if (iCurrentValues.Count() > 0)
+ {
+ TInt configDescriptorSize = 0;
+ LEAVEIFERRORL(iLdd.GetConfigurationDescriptorSize(configDescriptorSize));
+ HBufC8* configDescriptor = HBufC8::NewLC(configDescriptorSize);
+ TPtr8 ptr(configDescriptor->Des());
+
+ LOGTEXT2(_L8("Getting Configuration Descriptor (size = %d)"),configDescriptorSize);
+ LEAVEIFERRORL(iLdd.GetConfigurationDescriptor(ptr));
+
+// 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:"));
+ if(iIdPinState == EUsbBatteryChargingIdPinBRole)
+#else
+ if (ETrue)
+#endif
+ {
+ if (iCurrentValues.Count() > 0)
+ {
+ iCurrentIndexRequested = 0;
+ iRequestedCurrentValue = iCurrentValues[iCurrentIndexRequested];
+ LOGTEXT2(_L8("IdPin state is 0, current set to: %d"), iRequestedCurrentValue);
+ }
+ else
+ {
+ LOGTEXT(_L8("No vailable current found !"));
+ }
+ }
+ else
+ {
+ iRequestedCurrentValue = 0;
+ LOGTEXT(_L8("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));
+
+ CleanupStack::PopAndDestroy(configDescriptor);
+ }
+ }
+
+
+TAny* CUsbBatteryChargingPlugin::GetInterface(TUid aUid)
+ {
+ LOGTEXT(KNullDesC8);
+ LOGTEXT3(_L8(">>CUsbBatteryChargingPlugin::GetInterface this = [0x%08x], aUid = 0x%08x"), this, aUid);
+ (void)aUid;
+
+ TAny* ret = NULL;
+
+ LOGTEXT2(_L8("<<CUsbBatteryChargingPlugin::GetInterface ret = [0x%08x]"), ret);
+ return ret;
+ }
+
+void CUsbBatteryChargingPlugin::Panic(TUsbBatteryChargingPanic aPanic)
+ {
+ LOGTEXT2(_L8("*** CUsbBatteryChargingPlugin::Panic(%d) ***"),aPanic);
+ _LIT(KUsbChargingPanic,"USB Charging");
+ User::Panic(KUsbChargingPanic, aPanic);
+ }
+
+void CUsbBatteryChargingPlugin::UsbServiceStateChange(TInt /*aLastError*/, TUsbServiceState /*aOldState*/, TUsbServiceState /*aNewState*/)
+ {
+ // not used
+ }
+
+void CUsbBatteryChargingPlugin::PushRecoverState(TUsbChargingPluginState aRecoverState)
+ {
+ LOG_FUNC
+
+ if((aRecoverState == EPluginStateIdle)||
+ (aRecoverState == EPluginStateIdleNegotiated) ||
+ (aRecoverState == EPluginStateBEndedCableNotPresent) ||
+ (aRecoverState == EPluginStateNoValidCurrent))
+ {
+ iPluginStateToRecovery = aRecoverState;
+ }
+ }
+
+TUsbChargingPluginState CUsbBatteryChargingPlugin::PopRecoverState()
+ {
+ LOG_FUNC
+
+ SetState(iPluginStateToRecovery);
+
+ iPluginStateToRecovery = EPluginStateIdle;
+
+ return iPluginStateToRecovery;
+ }
+
+TUsbChargingPluginState CUsbBatteryChargingPlugin::SetState(TUsbChargingPluginState aState)
+ {
+ LOG_FUNC
+
+ switch (aState)
+ {
+ case EPluginStateIdle:
+ {
+ ResetPlugin();
+ iCurrentState = iPluginStates[aState];
+ }
+ break;
+ case EPluginStateCurrentNegotiating:
+ case EPluginStateCharging:
+ case EPluginStateNoValidCurrent:
+ case EPluginStateIdleNegotiated:
+ case EPluginStateUserDisabled:
+ case EPluginStateBEndedCableNotPresent:
+ {
+ iPluginState = aState;
+ iCurrentState = iPluginStates[aState];
+ }
+ break;
+ default:
+ // Should never happen ...
+ iPluginState = EPluginStateIdle;
+ iCurrentState = iPluginStates[EPluginStateIdle];
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetState: Invalid new state: aState = %d"), aState);
+
+ Panic(EUsbBatteryChargingPanicUnexpectedPluginState);
+ }
+ iPluginState = aState;
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetState, New state: aState = %d"), aState);
+
+ return iPluginState;
+ }
+
+void CUsbBatteryChargingPlugin::NegotiateChargingCurrent()
+ {
+ LOG_FUNC
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::StartNegotiation, iDeviceState = %d"), iDeviceState);
+ TRAPD(result, NegotiateNextCurrentValueL());
+ if(result == KErrNone)
+ {
+ SetState(EPluginStateCurrentNegotiating);
+ }
+ else
+ {
+ LOGTEXT2(_L8("Negotiation call failed, iVBusState = 1: result = %d"), result);
+ }
+ }
+
+void CUsbBatteryChargingPlugin::UsbDeviceStateChange(TInt aLastError,
+ TUsbDeviceState aOldState, TUsbDeviceState aNewState)
+ {
+ LOG_FUNC
+
+ iCurrentState->UsbDeviceStateChange(aLastError, aOldState, aNewState);
+ }
+
+void CUsbBatteryChargingPlugin::HandleRepositoryValueChangedL(const TUid& aRepository, TUint aId, TInt aVal)
+ {
+ LOG_FUNC
+
+ iCurrentState->HandleRepositoryValueChangedL(aRepository, aId, aVal);
+ }
+
+void CUsbBatteryChargingPlugin::DeviceStateTimeout()
+ {
+ LOG_FUNC
+
+ iCurrentState->DeviceStateTimeout();
+ }
+
+void CUsbBatteryChargingPlugin::NegotiateNextCurrentValueL()
+ {
+ LOG_FUNC
+
+ iDeviceStateTimer->Cancel();
+ TUint newCurrent = 0;
+
+ if ((iPluginState == EPluginStateIdle) && iCurrentValues.Count() > 0)
+ {
+ // i.e. we haven't requested anything yet, and there are some current values to try
+ iCurrentIndexRequested = 0;
+ newCurrent = iCurrentValues[iCurrentIndexRequested];
+ }
+ else if (iPluginState == EPluginStateCurrentNegotiating && ( iCurrentIndexRequested + 1) < iCurrentValues.Count())
+ {
+ // there are more current values left to try
+ iCurrentIndexRequested++;
+ newCurrent = iCurrentValues[iCurrentIndexRequested];
+ }
+ else if(iRequestedCurrentValue != 0)
+ {
+ // There isn't a 0ma round set from the Repository source -> 10208DD7.txt
+ // Just add it to make sure the device can be accepted by host
+ newCurrent = 0;
+ }
+ else
+ {
+ // Warning 0001: If you go here, something wrong happend, check it.
+ __ASSERT_DEBUG(0,Panic(EUsbBatteryChargingPanicBadCharingCurrentNegotiation));
+ }
+
+ RequestCurrentL(newCurrent);
+ iRequestedCurrentValue = newCurrent;
+ iPluginState = EPluginStateCurrentNegotiating;
+ }
+
+void CUsbBatteryChargingPlugin::ResetPlugin()
+ {
+ LOG_FUNC
+
+ if((iPluginState != EPluginStateIdle))
+ {
+ iDeviceStateTimer->Cancel(); // doesn't matter if not running
+ iPluginState = EPluginStateIdle;
+ iPluginStateToRecovery = EPluginStateIdle;
+ LOGTEXT2(_L8("PluginState => EPluginStateIdle(%d)"),iPluginState);
+
+ iRequestedCurrentValue = 0;
+ iCurrentIndexRequested = 0;
+ iAvailableMilliAmps = 0;
+ SetNegotiatedCurrent(0);
+ TRAP_IGNORE(SetInitialConfigurationL());
+ }
+ }
+
+void CUsbBatteryChargingPlugin::RequestCurrentL(TUint aMilliAmps)
+ {
+ LOG_FUNC
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::RequestCurrent aMilliAmps = %d"), aMilliAmps);
+
+ if((EPluginStateCurrentNegotiating == iPluginState) && (iRequestedCurrentValue != aMilliAmps))
+ {
+ TInt configDescriptorSize = 0;
+ LEAVEIFERRORL(iLdd.GetConfigurationDescriptorSize(configDescriptorSize));
+ HBufC8* configDescriptor = HBufC8::NewLC(configDescriptorSize);
+ TPtr8 ptr(configDescriptor->Des());
+
+ LOGTEXT2(_L8("Getting Configuration Descriptor (size = %d)"),configDescriptorSize);
+ LEAVEIFERRORL(iLdd.GetConfigurationDescriptor(ptr));
+
+ // 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));
+ TUint oldCurrentValue = ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] << 1;
+ LOGTEXT2(_L8("(old value was %d 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"));
+ ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] = (aMilliAmps >> 1);
+ LOGTEXT(_L8("Setting Updated Configuration Descriptor"));
+ LEAVEIFERRORL(iLdd.SetConfigurationDescriptor(ptr));
+ LOGTEXT(_L8("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());
+ iDeviceStateTimer->Cancel();
+ iDeviceStateTimer->Start(TTimeIntervalMicroSeconds32(KUsbBatteryChargingCurrentRequestTimeout));
+ }
+
+void CUsbBatteryChargingPlugin::ReadCurrentRequestValuesL()
+ {
+ LOG_FUNC
+
+ CRepository* repository = CRepository::NewLC(KUsbBatteryChargingCentralRepositoryUid);
+
+ TInt numberOfCurrents = 0;
+ repository->Get(KUsbBatteryChargingKeyNumberOfCurrentValues, numberOfCurrents);
+
+ TInt i = 0;
+ for (i=0; i<numberOfCurrents; i++)
+ {
+ TInt value;
+ repository->Get(KUsbBatteryChargingCurrentValuesOffset + i, value);
+ iCurrentValues.Append(static_cast<TUint>(value));
+ LOGTEXT3(_L8("CurrentValue %d = %dmA"),i,value);
+ }
+
+ CleanupStack::PopAndDestroy(repository);
+ }
+
+void CUsbBatteryChargingPlugin::StartCharging(TUint aMilliAmps)
+ {
+ LOG_FUNC
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::StartCharging aMilliAmps = %d"), aMilliAmps);
+
+ // do licensee specific functionality (if any)
+ iLicenseeHooks->StartCharging(aMilliAmps);
+
+#ifdef __FLOG_ACTIVE
+ TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ aMilliAmps);
+ LOGTEXT3(_L8("Set P&S current = %dmA - err = %d"),aMilliAmps,err);
+#else
+ (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ aMilliAmps);
+#endif
+
+ SetState(EPluginStateCharging);
+ }
+
+void CUsbBatteryChargingPlugin::StopCharging()
+ {
+ LOG_FUNC
+
+ // do licensee specific functionality (if any)
+ iLicenseeHooks->StopCharging();
+
+#ifdef __FLOG_ACTIVE
+ TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ 0);
+ LOGTEXT2(_L8("Set P&S current = 0mA - err = %d"),err);
+#else
+ (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingChargingCurrent,
+ 0);
+#endif
+ }
+
+void CUsbBatteryChargingPlugin::SetNegotiatedCurrent(TUint aMilliAmps)
+ {
+ LOG_FUNC
+
+ LOGTEXT2(_L8(">>CUsbBatteryChargingPlugin::SetNegotiatedCurrent aMilliAmps = %d"), aMilliAmps);
+
+ // Ignore errors - not much we can do if it fails
+#ifdef __FLOG_ACTIVE
+ TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent,
+ aMilliAmps);
+ LOGTEXT3(_L8("Set P&S current = %dmA - err = %d"),aMilliAmps,err);
+#else
+ (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory,
+ KPropertyUidUsbBatteryChargingAvailableCurrent,
+ aMilliAmps);
+#endif
+ }
+
+
+#ifndef __FLOG_ACTIVE
+void CUsbBatteryChargingPlugin::LogStateText(TUsbDeviceState /*aState*/)
+ {
+ LOG_FUNC
+ }
+#else
+void CUsbBatteryChargingPlugin::LogStateText(TUsbDeviceState aState)
+ {
+ LOG_FUNC
+
+ switch (aState)
+ {
+ case EUsbDeviceStateUndefined:
+ LOGTEXT(_L8(" ***** UNDEFINED *****"));
+ break;
+ case EUsbDeviceStateDefault:
+ LOGTEXT(_L8(" ***** DEFAULT *****"));
+ break;
+ case EUsbDeviceStateAttached:
+ LOGTEXT(_L8(" ***** ATTACHED *****"));
+ break;
+ case EUsbDeviceStatePowered:
+ LOGTEXT(_L8(" ***** POWERED *****"));
+ break;
+ case EUsbDeviceStateConfigured:
+ LOGTEXT(_L8(" ***** CONFIGURED *****"));
+ break;
+ case EUsbDeviceStateAddress:
+ LOGTEXT(_L8(" ***** ADDRESS *****"));
+ break;
+ case EUsbDeviceStateSuspended:
+ LOGTEXT(_L8(" ***** SUSPENDED *****"));
+ break;
+ default:
+ break;
+ }
+ }
+#endif
+
+void CUsbBatteryChargingPlugin::MpsoVBusStateChanged(TInt aNewState)
+ {
+ LOG_FUNC
+
+ iCurrentState->MpsoVBusStateChanged(aNewState);
+ }
+
+
+// For host OTG enabled charging plug-in
+#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV
+void CUsbBatteryChargingPlugin::MpsoIdPinStateChanged(TInt aValue)
+ {
+ LOG_FUNC
+
+ iCurrentState->MpsoIdPinStateChanged(aValue);
+ }
+
+void CUsbBatteryChargingPlugin::MpsoOtgStateChangedL(TUsbOtgState aNewState)
+ {
+ LOG_FUNC
+
+ iCurrentState->MpsoOtgStateChangedL(aNewState);
+ }
+#endif