/*

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

static const TInt KUsbBatteryChargingConfigurationDescriptorCurrentOffset = 8; // see bMaxPower in section 9.6.3 of USB Spec 2.0

static const TInt KUsbBatteryChargingCurrentRequestTimeout = 3000000; // 3 seconds

/**

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()

    {

    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()

    {

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

        {

        }

    if(err == KErrNone || err == KErrAlreadyExists)

        {

        err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,

                                        KPropertyUidUsbBatteryChargingAvailableCurrent,

                                        0);

        }

    else

        {

        static_cast<void> (RProperty::Delete (

                KPropertyUidUsbBatteryChargingCategory,

                KPropertyUidUsbBatteryChargingAvailableCurrent ));

        }

    err = RProperty::Set(KPropertyUidUsbBatteryChargingCategory,

                                        KPropertyUidUsbBatteryChargingChargingCurrent,

                                        0);

    if(err != KErrNone)

        {

        static_cast<void> (RProperty::Delete (

                KPropertyUidUsbBatteryChargingCategory,

                KPropertyUidUsbBatteryChargingAvailableCurrent ));

        static_cast<void> (RProperty::Delete (

                KPropertyUidUsbBatteryChargingCategory,

                KPropertyUidUsbBatteryChargingChargingCurrent ));

        }

    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;

        }

    Observer().RegisterStateObserverL(*this);

    iLicenseeHooks = CUsbBatteryChargingLicenseeHooks::NewL();

    // Set initial recovery state to idle

    PushRecoverState(EPluginStateIdle);

    }

// 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()

    {

    if (iCurrentValues.Count() > 0)

        {

        TInt configDescriptorSize = 0;

        HBufC8* configDescriptor = HBufC8::NewLC(configDescriptorSize);

        TPtr8 ptr(configDescriptor->Des());

// For host OTG enabled charging plug-in

#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

        // Get first power to put in configurator

        if(iIdPinState == EUsbBatteryChargingIdPinBRole)

#else

        if (ETrue)

#endif

        	{

            if (iCurrentValues.Count() > 0)

                {

                iCurrentIndexRequested = 0;

                iRequestedCurrentValue = iCurrentValues[iCurrentIndexRequested];

                }

            else

                {

                }

            }

        else

            {

            iRequestedCurrentValue = 0;

            }

        TUint oldCurrentValue = ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] << 1;

        ptr[KUsbBatteryChargingConfigurationDescriptorCurrentOffset] = (iRequestedCurrentValue >> 1);

        CleanupStack::PopAndDestroy(configDescriptor); 

        }

    }

TAny* CUsbBatteryChargingPlugin::GetInterface(TUid aUid)

    {

    (void)aUid;

    TAny* ret = NULL;

    return ret;

    }

void CUsbBatteryChargingPlugin::Panic(TUsbBatteryChargingPanic 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)

    {

    if((aRecoverState == EPluginStateIdle)||

       (aRecoverState == EPluginStateIdleNegotiated) ||

       (aRecoverState == EPluginStateBEndedCableNotPresent) ||

       (aRecoverState == EPluginStateNoValidCurrent))

        {

        iPluginStateToRecovery = aRecoverState;

        }

    }

TUsbChargingPluginState CUsbBatteryChargingPlugin::PopRecoverState()

    {

    SetState(iPluginStateToRecovery);

    iPluginStateToRecovery = EPluginStateIdle;

    return iPluginStateToRecovery;

    }

TUsbChargingPluginState CUsbBatteryChargingPlugin::SetState(TUsbChargingPluginState aState)

    {

    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];

            Panic(EUsbBatteryChargingPanicUnexpectedPluginState);

        }

    iPluginState = aState;

    return iPluginState;

    }

void CUsbBatteryChargingPlugin::NegotiateChargingCurrent()

    {

    TRAPD(result, NegotiateNextCurrentValueL());

    if(result == KErrNone)

        {

        SetState(EPluginStateCurrentNegotiating);

        }

    else

        {

        }

    }

void CUsbBatteryChargingPlugin::UsbDeviceStateChange(TInt aLastError,

        TUsbDeviceState aOldState, TUsbDeviceState aNewState)

    {

    iCurrentState->UsbDeviceStateChange(aLastError, aOldState, aNewState);

    }

void CUsbBatteryChargingPlugin::HandleRepositoryValueChangedL(const TUid& aRepository, TUint aId, TInt aVal)

    {

    iCurrentState->HandleRepositoryValueChangedL(aRepository, aId, aVal);

    }

void CUsbBatteryChargingPlugin::DeviceStateTimeout()

    {

    iCurrentState->DeviceStateTimeout();

    }

void CUsbBatteryChargingPlugin::NegotiateNextCurrentValueL()

    {

    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()

    {

    if((iPluginState != EPluginStateIdle))

        {

        iDeviceStateTimer->Cancel(); // doesn't matter if not running

        iPluginState = EPluginStateIdle;

        iPluginStateToRecovery = EPluginStateIdle;

        iRequestedCurrentValue = 0;

        iCurrentIndexRequested = 0;

        iAvailableMilliAmps = 0;

        SetNegotiatedCurrent(0);

        TRAP_IGNORE(SetInitialConfigurationL());

        }

    }

void CUsbBatteryChargingPlugin::RequestCurrentL(TUint aMilliAmps)

    {

    if((EPluginStateCurrentNegotiating == iPluginState) && (iRequestedCurrentValue != aMilliAmps))

        {