diff -r 21625e5de155 -r 93c0009bd947 usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp --- a/usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp Mon Sep 06 11:27:08 2010 +0800 +++ b/usbmgmt/usbmgr/usbman/chargingplugin/src/CUsbBatteryChargingPlugin.cpp Thu Sep 16 12:03:29 2010 +0800 @@ -18,18 +18,15 @@ /** @file @internalComponent */ -#include "CUsbBatteryChargingPlugin.h" #include #include -#include #include -#include #include #include - +#include +#include "CUsbBatteryChargingPlugin.h" #include "chargingstates.h" -#include "cusbbatterycharginglicenseehooks.h" #include "reenumerator.h" #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV // For host OTG enabled charging plug-in @@ -46,6 +43,11 @@ static const TInt KUsbBatteryChargingConfigurationDescriptorCurrentOffset = 8; // see bMaxPower in section 9.6.3 of USB Spec 2.0 static const TInt KUsbBatteryChargingCurrentRequestTimeout = 3000000; // 3 seconds +static const TUint8 KMinCurrent = 8; // See USB OTG specification , min current +static const TUint8 KbmAttributes = 7; // see bmAttributes in section 9.6.3 of USB Spec 2.0 +static const TUint8 KSelfPowered = 0x40; // Bitmask to bmAttributes (01000000) + + /** @@ -71,8 +73,6 @@ iCurrentValues.Close(); delete iDeviceReEnumerator; delete iDeviceStateTimer; - delete iRepositoryNotifier; - delete iLicenseeHooks; // For host OTG enabled charging plug-in #ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV @@ -101,21 +101,29 @@ */ void CUsbBatteryChargingPlugin::ConstructL() { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_ENTRY ); + OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_ENTRY ); + iUsbSpeedType = EUsbFullSpeed; + iChargingInfo().iChargingPortType = EUsbChargingPortTypeStandardDownstreamPort; + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusNone; + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; +#ifdef SYMBIAN_USB_BATTERYCHARGING_V1_1 + iChargingInfo().iChargingPortType = EUsbChargingPortTypeNone; + iChargerDetectotCaps.iCapabilities = 0; +#endif + iLastPublishedInfo = iChargingInfo(); + // 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); @@ -123,66 +131,34 @@ 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 - { - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err ); - User::Leave(err ); - } + KPropertyUidUsbBatteryChargingInfo, + RProperty::EByteArray, + sizeof(TPublishedUsbChargingInfo)); if(err == KErrNone || err == KErrAlreadyExists) { err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingAvailableCurrent, - 0); + KPropertyUidUsbBatteryChargingInfo, + iChargingInfo); } - else - { - static_cast (RProperty::Delete ( - KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingAvailableCurrent )); - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP1, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err ); + else + { User::Leave(err); - } - - err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingChargingCurrent, - 0); + } if(err != KErrNone) { static_cast (RProperty::Delete ( KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingAvailableCurrent )); - static_cast (RProperty::Delete ( - KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingChargingCurrent )); - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP2, "CUsbBatteryChargingPlugin::ConstructL;leave with error=%d", err ); - User::Leave(err ); + KPropertyUidUsbBatteryChargingInfo )); + User::Leave(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(); @@ -209,14 +185,11 @@ OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP3, "CUsbBatteryChargingPlugin::ConstructL;PluginState => EPluginStateADevice(%d)", iPluginState ); } - Observer().RegisterStateObserverL(*this); - - iLicenseeHooks = CUsbBatteryChargingLicenseeHooks::NewL(); - OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_DUP4, "CUsbBatteryChargingPlugin::ConstructL;Created licensee specific hooks" ); - - // Set initial recovery state to idle - PushRecoverState(EPluginStateIdle); - + Observer().RegisterStateObserverL(*this); +#ifdef SYMBIAN_USB_BATTERYCHARGING_V1_1 + MUsbChargingNotify* charging = static_cast(this); + Observer().RegisterChargingObserverL(*charging); +#endif OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_CONSTRUCTL_EXIT ); } @@ -224,12 +197,6 @@ 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) { @@ -323,7 +290,6 @@ (void)aUid; TAny* ret = NULL; - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_GETINTERFACE_DUP2, "CUsbBatteryChargingPlugin::GetInterface;ret = [0x%08x]", ret ); return ret; } @@ -340,32 +306,6 @@ // not used } -void CUsbBatteryChargingPlugin::PushRecoverState(TUsbChargingPluginState aRecoverState) - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_PUSHRECOVERSTATE_ENTRY ); - - if((aRecoverState == EPluginStateIdle)|| - (aRecoverState == EPluginStateIdleNegotiated) || - (aRecoverState == EPluginStateBEndedCableNotPresent) || - (aRecoverState == EPluginStateNoValidCurrent)) - { - iPluginStateToRecovery = aRecoverState; - } - OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_PUSHRECOVERSTATE_EXIT ); - } - -TUsbChargingPluginState CUsbBatteryChargingPlugin::PopRecoverState() - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_POPRECOVERSTATE_ENTRY ); - - SetState(iPluginStateToRecovery); - - iPluginStateToRecovery = EPluginStateIdle; - - OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_POPRECOVERSTATE_EXIT ); - return iPluginStateToRecovery; - } - TUsbChargingPluginState CUsbBatteryChargingPlugin::SetState(TUsbChargingPluginState aState) { OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_SETSTATE_ENTRY ); @@ -379,16 +319,11 @@ } break; case EPluginStateCurrentNegotiating: - case EPluginStateCharging: case EPluginStateNoValidCurrent: case EPluginStateIdleNegotiated: - case EPluginStateUserDisabled: case EPluginStateBEndedCableNotPresent: - { - iPluginState = aState; iCurrentState = iPluginStates[aState]; - } - break; + break; default: // Should never happen ... iPluginState = EPluginStateIdle; @@ -429,22 +364,16 @@ OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_USBDEVICESTATECHANGE_ENTRY ); iCurrentState->UsbDeviceStateChange(aLastError, aOldState, aNewState); + UpdateChargingInfo(); OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_USBDEVICESTATECHANGE_EXIT ); } -void CUsbBatteryChargingPlugin::HandleRepositoryValueChangedL(const TUid& aRepository, TUint aId, TInt aVal) - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_HANDLEREPOSITORYVALUECHANGEDL_ENTRY ); - - iCurrentState->HandleRepositoryValueChangedL(aRepository, aId, aVal); - OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_HANDLEREPOSITORYVALUECHANGEDL_EXIT ); - } - void CUsbBatteryChargingPlugin::DeviceStateTimeout() { OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_DEVICESTATETIMEOUT_ENTRY ); - iCurrentState->DeviceStateTimeout(); + iCurrentState->DeviceStateTimeout(); + UpdateChargingInfo(); OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_DEVICESTATETIMEOUT_EXIT ); } @@ -467,16 +396,14 @@ iCurrentIndexRequested++; newCurrent = iCurrentValues[iCurrentIndexRequested]; } - else if(iRequestedCurrentValue != 0) + else if(iRequestedCurrentValue != 0 && iRequestedCurrentValue != KMinCurrent) { - // 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; + newCurrent = KMinCurrent; } else { - // Warning 0001: If you go here, something wrong happend, check it. - __ASSERT_DEBUG(0,Panic(EUsbBatteryChargingPanicBadCharingCurrentNegotiation)); + iPluginState = EPluginStateNoValidCurrent; + User::Leave(EUsbBatteryChargingPanicBadCharingCurrentNegotiation); } RequestCurrentL(newCurrent); @@ -493,13 +420,13 @@ { iDeviceStateTimer->Cancel(); // doesn't matter if not running iPluginState = EPluginStateIdle; - iPluginStateToRecovery = EPluginStateIdle; OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_RESETPLUGIN, "CUsbBatteryChargingPlugin::ResetPlugin;PluginState => EPluginStateIdle(%d)", iPluginState ); iRequestedCurrentValue = 0; iCurrentIndexRequested = 0; iAvailableMilliAmps = 0; - SetNegotiatedCurrent(0); + iBDevMaxPower = 0; + UpdateChargingInfo(); TRAP_IGNORE(SetInitialConfigurationL()); } OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_RESETPLUGIN_EXIT ); @@ -532,6 +459,11 @@ User::Leave(err); } + // compliant to charging adaptation in modem adaptation + TUint8 bmAttributes = ptr[KbmAttributes]; + bmAttributes &= ~(KSelfPowered); + ptr[KbmAttributes] = bmAttributes; + // set bMaxPower field. One unit = 2mA, so need to halve aMilliAmps. 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; @@ -585,71 +517,6 @@ OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_READCURRENTREQUESTVALUESL_EXIT ); } -void CUsbBatteryChargingPlugin::StartCharging(TUint aMilliAmps) - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_ENTRY ); - - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING, "CUsbBatteryChargingPlugin::StartCharging;aMilliAmps=%u", aMilliAmps ); - - // do licensee specific functionality (if any) - iLicenseeHooks->StartCharging(aMilliAmps); - -#ifdef _DEBUG - TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingChargingCurrent, - aMilliAmps); - OstTraceExt2( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_DUP1, "CUsbBatteryChargingPlugin::StartCharging;Set P&S current = %umA - err = %d", aMilliAmps, err ); -#else - (void)RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingChargingCurrent, - aMilliAmps); -#endif - - SetState(EPluginStateCharging); - OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_STARTCHARGING_EXIT ); - } - -void CUsbBatteryChargingPlugin::StopCharging() - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_STOPCHARGING_ENTRY ); - - // do licensee specific functionality (if any) - iLicenseeHooks->StopCharging(); - -#ifdef _DEBUG - TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingChargingCurrent, - 0); - 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) - { - OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT_ENTRY ); - - OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_SETNEGOTIATEDCURRENT, "CUsbBatteryChargingPlugin::SetNegotiatedCurrent;aMilliAmps=%u", aMilliAmps ); - - // Ignore errors - not much we can do if it fails -#ifdef _DEBUG - TInt err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory, - KPropertyUidUsbBatteryChargingAvailableCurrent, - aMilliAmps); - 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 _DEBUG void CUsbBatteryChargingPlugin::LogStateText(TUsbDeviceState /*aState*/) { @@ -692,8 +559,12 @@ void CUsbBatteryChargingPlugin::MpsoVBusStateChanged(TInt aNewState) { OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOVBUSSTATECHANGED_ENTRY ); - - iCurrentState->MpsoVBusStateChanged(aNewState); + if (iChargingInfo().iChargingPortType == EUsbChargingPortTypeStandardDownstreamPort) + { + iCurrentState->MpsoVBusStateChanged(aNewState); + } + iVBusState = aNewState; + UpdateChargingInfo(); OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOVBUSSTATECHANGED_EXIT ); } @@ -705,6 +576,7 @@ OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOIDPINSTATECHANGED_ENTRY ); iCurrentState->MpsoIdPinStateChanged(aValue); + UpdateChargingInfo(); OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOIDPINSTATECHANGED_EXIT ); } @@ -713,6 +585,352 @@ OstTraceFunctionEntry0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOOTGSTATECHANGEDL_ENTRY ); iCurrentState->MpsoOtgStateChangedL(aNewState); - OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOOTGSTATECHANGEDL_EXIT ); + UpdateChargingInfo(); + OstTraceFunctionExit0( REF_CUSBBATTERYCHARGINGPLUGIN_MPSOOTGSTATECHANGEDL_EXIT ); } #endif + + +#ifdef SYMBIAN_USB_BATTERYCHARGING_V1_1 +void CUsbBatteryChargingPlugin::UsbChargingPortType(TUint aChargingPortType) + { + OstTraceExt1( TRACE_NORMAL, CUSBBATTERYCHARGINGPLUGIN_USBCHARGINGPORTTYPE, "CUsbBatteryChargingPlugin::UsbChargingPortType;ChargingTypeToString(aChargingPortType)=%s", *ChargingTypeToString(aChargingPortType) ); + ChargingTypeToString(aChargingPortType); + switch (aChargingPortType) + { + case KUsbChargingPortTypeNone: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeNone; + break; + case KUsbChargingPortTypeUnsupported: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeUnsupported; + break; + case KUsbChargingPortTypeDedicatedChargingPort: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeDedicatedChargingPort; + break; + case KUsbChargingPortTypeChargingDownstreamPort: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeChargingDownstreamPort; + break; + case KUsbChargingPortTypeStandardDownstreamPort: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeStandardDownstreamPort; + break; + case KUsbChargingPortTypeAcaRidA: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeAcaRidA; + break; + case KUsbChargingPortTypeAcaRidB: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeAcaRidB; + break; + case KUsbChargingPortTypeAcaRidC: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeAcaRidC; + break; + case KUsbChargingPortTypeChargingPort: + iChargingInfo().iChargingPortType = EUsbChargingPortTypeChargingPort; + break; + default: + break; + } + iLdd.ChargerDetectorCaps(iChargerDetectotCaps); + iCurrentState->UsbChargingPortType(aChargingPortType); + UpdateChargingInfo(); + } +#endif + +_LIT8(KPortTypeNone, "PortTypeNone"); +_LIT8(KPortTypeUnsupported, "PortTypeUnsupported"); +_LIT8(KPortTypeDedicatedChargingPort, "PortTypeDedicatedChargingPort"); +_LIT8(KPortTypeStandardDownstreamPort, "PortTypeStandardDownstreamPort"); +_LIT8(KPortTypeChargingDownstreamPort, "PortTypeChargingDownstreamPort"); +_LIT8(KPortTypeAcaRidA, "PortTypeAcaRidA"); +_LIT8(KPortTypeAcaRidB, "PortTypeAcaRidB"); +_LIT8(KPortTypeAcaRidC, "PortTypeAcaRidC"); +_LIT8(KPortTypeChargingPort, "PortTypeChargingPort"); + + +const TDesC8* CUsbBatteryChargingPlugin::ChargingTypeToString(TUint aChargingType) + { + const TDesC8* str = NULL; + switch (aChargingType) + { + case EUsbChargingPortTypeNone: + str = &KPortTypeNone; + break; + case EUsbChargingPortTypeUnsupported: + str = &KPortTypeUnsupported; + break; + case EUsbChargingPortTypeDedicatedChargingPort: + str = &KPortTypeDedicatedChargingPort; + break; + case EUsbChargingPortTypeChargingDownstreamPort: + str = &KPortTypeChargingDownstreamPort; + break; + case EUsbChargingPortTypeStandardDownstreamPort: + str = &KPortTypeStandardDownstreamPort; + break; + case EUsbChargingPortTypeAcaRidA: + str = &KPortTypeAcaRidA; + break; + case EUsbChargingPortTypeAcaRidB: + str = &KPortTypeAcaRidB; + break; + case EUsbChargingPortTypeAcaRidC: + str = &KPortTypeAcaRidC; + break; + case EUsbChargingPortTypeChargingPort: + str = &KPortTypeChargingPort; + break; + default: + break; + } + return str; + } + +void CUsbBatteryChargingPlugin::QueryCurrentSpeed() + { + if (iChargingInfo().iChargingPortType == EUsbChargingPortTypeChargingDownstreamPort) + { + if (iLdd.CurrentlyUsingHighSpeed()) + { + OstTrace0( TRACE_NORMAL, CUSBBATTERYCHARGINGPLUGIN_QUERYCURRENTSPEED, "CUsbBatteryChargingPlugin::QueryCurrentSpeed is high speed" ); + iUsbSpeedType = EUsbHighSpeed; + } + else + { + OstTrace0( TRACE_NORMAL, DUP1_CUSBBATTERYCHARGINGPLUGIN_QUERYCURRENTSPEED, "CUsbBatteryChargingPlugin::QueryCurrentSpeed is full speed" ); + iUsbSpeedType = EUsbFullSpeed; + } + } + } + +#ifdef SYMBIAN_USB_BATTERYCHARGING_V1_1 +void CUsbBatteryChargingPlugin::UpdateChargingInfo() + { + OstTraceFunctionEntry0( CUSBBATTERYCHARGINGPLUGIN_UPDATECHARGINGINFO_ENTRY ); + const TUint16 KIDev_Dchg = 1800; + const TUint16 KIDev_Chg = 1500; + const TUint16 KIDev_Hchg_Lfs = 1500; + const TUint16 KIDev_Hchg_Hs = 900; + const TUint16 KIDev_Hchg_Hs_Chirp = 560; + const TUint16 KIDev_Avaiable = 500; + const TUint16 KIDev_Suspend = 2; + const TUint16 KVBus_Chg = 4500; + const TUint16 KVBus_Dchg = 2000; + + + QueryCurrentSpeed(); +//set iUsbConnStatus field + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusNone; + if (EUsbChargingPortTypeStandardDownstreamPort == iChargingInfo().iChargingPortType + && IsUsbChargingPossible()) + { + switch (iDeviceState) + { + case EUsbDeviceStateSuspended: + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusSuspend; + break; + case EUsbDeviceStateConfigured: + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusConfigured; + break; + default: + break; + } + } +//set current and voltage field + switch (iChargingInfo().iChargingPortType) + { + case EUsbChargingPortTypeDedicatedChargingPort: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Avaiable; + iChargingInfo().iMaxVbusCurrent = KIDev_Dchg; + iChargingInfo().iMinVbusVoltage = KVBus_Dchg; + break; + case EUsbChargingPortTypeChargingPort: + case EUsbChargingPortTypeChargingDownstreamPort: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Avaiable; + iChargingInfo().iMinVbusVoltage = KVBus_Dchg; + if (iChargerDetectotCaps.iCapabilities & KChargerDetectorCapChirpCurrentLimiting) + { + if (iUsbSpeedType == EUsbFullSpeed) + { + iChargingInfo().iMaxVbusCurrent = KIDev_Hchg_Lfs; + } + else + { + iChargingInfo().iMaxVbusCurrent = KIDev_Hchg_Hs; + } + } + else + { + if (iDeviceState == EUsbDeviceStateConfigured && iUsbSpeedType == EUsbFullSpeed) + { + iChargingInfo().iMaxVbusCurrent = KIDev_Hchg_Lfs; + } + else + { + iChargingInfo().iMaxVbusCurrent = KIDev_Hchg_Hs_Chirp; + } + } + break; + case EUsbChargingPortTypeNone: + case EUsbChargingPortTypeUnsupported: + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; + break; + case EUsbChargingPortTypeStandardDownstreamPort: + if (IsUsbChargingPossible()) + { + switch (iDeviceState) + { + case EUsbDeviceStateConfigured: + iChargingInfo().iMinAvailableVbusCurrent = iAvailableMilliAmps; + iChargingInfo().iMaxVbusCurrent = iAvailableMilliAmps; + iChargingInfo().iMinVbusVoltage = KVBus_Chg; + break; + case EUsbDeviceStateSuspended: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Suspend; + iChargingInfo().iMaxVbusCurrent = KIDev_Suspend; + iChargingInfo().iMinVbusVoltage = KVBus_Chg; + break; + default: + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; + break; + } + } + else + { + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; + } + break; + case EUsbChargingPortTypeAcaRidA: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Avaiable - iBDevMaxPower; + iChargingInfo().iMaxVbusCurrent = KIDev_Chg; + iChargingInfo().iMinVbusVoltage = KVBus_Dchg; + break; + case EUsbChargingPortTypeAcaRidB: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Avaiable; + iChargingInfo().iMaxVbusCurrent = KIDev_Chg; + iChargingInfo().iMinVbusVoltage = KVBus_Dchg; + break; + case EUsbChargingPortTypeAcaRidC: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Avaiable; + iChargingInfo().iMaxVbusCurrent = KIDev_Chg; + iChargingInfo().iMinVbusVoltage = KVBus_Dchg; + break; + default: + break; + } + PublishChargingInfo(); + OstTraceFunctionExit0( CUSBBATTERYCHARGINGPLUGIN_UPDATECHARGINGINFO_EXIT ); + } + +#else +void CUsbBatteryChargingPlugin::UpdateChargingInfo() + { + OstTraceFunctionEntry0( CUSBBATTERYCHARGINGPLUGIN_UPDATECHARGINGINF1_ENTRY ); + const TUint16 KIDev_Suspend = 2; + const TUint16 KVBus_Chg = 4500; + + + QueryCurrentSpeed(); +//set iUsbConnStatus field + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusNone; + if (EUsbChargingPortTypeStandardDownstreamPort == iChargingInfo().iChargingPortType + && IsUsbChargingPossible()) + { + switch (iDeviceState) + { + case EUsbDeviceStateSuspended: + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusSuspend; + break; + case EUsbDeviceStateConfigured: + iChargingInfo().iUsbConnStatus = EUsbConnectionStatusConfigured; + break; + default: + break; + } + } +//set current and voltage field + switch (iChargingInfo().iChargingPortType) + { + case EUsbChargingPortTypeStandardDownstreamPort: + if (IsUsbChargingPossible()) + { + switch (iDeviceState) + { + case EUsbDeviceStateConfigured: + iChargingInfo().iMinAvailableVbusCurrent = iAvailableMilliAmps; + iChargingInfo().iMaxVbusCurrent = iAvailableMilliAmps; + iChargingInfo().iMinVbusVoltage = KVBus_Chg; + break; + case EUsbDeviceStateSuspended: + iChargingInfo().iMinAvailableVbusCurrent = KIDev_Suspend; + iChargingInfo().iMaxVbusCurrent = KIDev_Suspend; + iChargingInfo().iMinVbusVoltage = KVBus_Chg; + break; + default: + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; + break; + } + } + else + { + iChargingInfo().iMinAvailableVbusCurrent = 0; + iChargingInfo().iMaxVbusCurrent = 0; + iChargingInfo().iMinVbusVoltage = 0; + } + break; + default: + break; + } + PublishChargingInfo(); + OstTraceFunctionExit0( CUSBBATTERYCHARGINGPLUGIN_UPDATECHARGINGINF1_EXIT ); + } + +#endif + + +void CUsbBatteryChargingPlugin::PublishChargingInfo() + { + OstTraceFunctionEntry0( CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_ENTRY ); + OstTraceExt1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP1, "charging type: %s", + *ChargingTypeToString(iChargingInfo().iChargingPortType) ); + OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP2, "iUsbConnStatus %d", + iChargingInfo().iUsbConnStatus ); + OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP3, "iMinAvailableVbusCurrent %d", + iChargingInfo().iMinAvailableVbusCurrent ); + OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP4, "iMaxVbusCurrent %d", + iChargingInfo().iMaxVbusCurrent ); + OstTrace1( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP5, "iMinVbusVoltage %d", + iChargingInfo().iMinVbusVoltage ); + + if (iLastPublishedInfo.iChargingPortType != iChargingInfo().iChargingPortType + || iLastPublishedInfo.iUsbConnStatus != iChargingInfo().iUsbConnStatus + || iLastPublishedInfo.iMinAvailableVbusCurrent != iChargingInfo().iMinAvailableVbusCurrent + || iLastPublishedInfo.iMaxVbusCurrent != iChargingInfo().iMaxVbusCurrent + || iLastPublishedInfo.iMinVbusVoltage != iChargingInfo().iMinVbusVoltage) + { + OstTrace0( TRACE_NORMAL, REF_CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_DUP6, "info changed, publish it"); + RProperty::Set(KPropertyUidUsbBatteryChargingCategory, + KPropertyUidUsbBatteryChargingInfo, + iChargingInfo); + } + iLastPublishedInfo = iChargingInfo(); + OstTraceFunctionExit0( CUSBBATTERYCHARGINGPLUGIN_PUBLISHCHARGINGINFO_EXIT ); + } + +#ifdef SYMBIAN_USB_BATTERYCHARGING_V1_1 + +void CUsbBatteryChargingPlugin::PeerDeviceMaxPower(TUint aCurrent) + { + OstTraceFunctionEntry0( CUSBBATTERYCHARGINGPLUGIN_PEERDEVICEMAXPOWER_ENTRY ); + const TUint16 KIBDev_Drawn = 500; + iBDevMaxPower = (aCurrent < KIBDev_Drawn)?aCurrent:KIBDev_Drawn; + UpdateChargingInfo(); + OstTraceFunctionExit0( CUSBBATTERYCHARGINGPLUGIN_PEERDEVICEMAXPOWER_EXIT ); + } +#endif +