/*
* 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