/*

* Copyright (c) 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"

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

*

*/

#include <e32base.h>

#include <e32cons.h>

#ifndef __OVER_DUMMYUSBSCLDD__

#include <d32usbc.h>//EEndPoint2

#else

#include <dummyusbsclddapi.h>

#endif

#include "ncmdatainterface.h"

#include "ncmdatareceiver.h"

#include "ncmdatasender.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "ncmdatainterfaceTraces.h"

#endif

const TInt KAltSetting1 = 1;

const TInt KAltSetting0 = 0;

CNcmDataInterface* CNcmDataInterface::NewL(MNcmDataObserver& aEngine,

        RDevUsbcScClient& aLdd)

    {

    CNcmDataInterface *self = new (ELeave) CNcmDataInterface(aEngine, aLdd);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CNcmDataInterface::CNcmDataInterface(MNcmDataObserver& aEngine,

        RDevUsbcScClient& aLdd) :

    CActive(CActive::EPriorityStandard), iEngine(aEngine), iLdd(aLdd)

    {

    CActiveScheduler::Add(this);

    }

void CNcmDataInterface::ConstructL()

    {

    OstTraceFunctionEntry0(CNCMDATAINTERFACE_CONSTRUCTL);

    iReceiver = CNcmDataReceiver::NewL(iLdd, *this);

    iSender = CNcmDataSender::NewL(iLdd, *this);

    OstTraceFunctionExit0(CNCMDATAINTERFACE_CONSTRUCTL_DUP01);

    }

CNcmDataInterface::~CNcmDataInterface()

    {

    OstTraceFunctionEntry0(CNCMDATAINTERFACE_CNCMDATAINTERFACE_DUP01);

    Cancel();

    delete iReceiver;

    delete iSender;

    OstTraceFunctionExit0(CNCMDATAINTERFACE_CNCMDATAINTERFACE_DUP02);

    }

/**

 Start the NCM data channel

 */

void CNcmDataInterface::Start()

    {

    OstTraceFunctionEntry0(CNCMDATAINTERFACE_START);

    if (!iStarted)

        {

        iReceiver->Start();

        iSender->Start();

        iStarted = ETrue;

        }

    OstTraceFunctionExit0(CNCMDATAINTERFACE_START_DUP01);

    }

/**

 Stop the NCM data channel

 */

void CNcmDataInterface::Stop()

    {

    OstTraceFunctionEntry0(CNCMDATAINTERFACE_STOP);

    if (iStarted)

        {

        iReceiver->Stop();

        iSender->Stop();

        iStarted = EFalse;

        //after stop().

        if (KAltSetting1 == iAltSetting)

            {

            iAltSetting = KAltSetting0;

            }

        }

    OstTraceFunctionExit0(CNCMDATAINTERFACE_STOP_DUP01);

    }

/**

 Send packet data from upper link to NCM host

 */

TInt CNcmDataInterface::Send(RMBufChain &aPacket)

    {

    const TInt KContinue = 1;

    const TInt KStop = 0;

    TInt ret = iSender->Send(aPacket);

    if (ret == KErrNone)

        {

        return KContinue;

        }

    else if (ret == KErrNotReady || ret == KErrCongestion)

        {

        return KStop;

        }

    else

        {

        iEngine.DataError(ret);

        return KStop;

        }

    }

/**

 * Acitve this AO to monitor the LDD's alt-setting changes.

 */

void CNcmDataInterface::ActivateLdd()

    {

    TInt alt = 0;

    TInt ret = KErrNone;

    ret = iLdd.GetAlternateSetting(alt);

    OstTraceExt2(TRACE_NORMAL, CNCMDATAINTERFACE_ACTIVATELDD, "ActivateLDD:alt=%d, ret=%d", alt, ret);

    if (KErrNone == ret)

        {

        if (iAltSetting == alt)

            {

            iLdd.AlternateDeviceStatusNotify(iStatus, iIfState);

            SetActive();

            }

        else

            {

            TRequestStatus* status = &iStatus;

            iStatus = KRequestPending;

            iIfState = KUsbAlternateSetting | alt;

            SetActive();

            User::RequestComplete(status, KErrNone);

            }

        }

    else

        {

        //It's possible when Usb Device Status is not configed.

        iLdd.AlternateDeviceStatusNotify(iStatus, iIfState);

        SetActive();

        }

    }

void CNcmDataInterface::RunL()

    {

    OstTraceExt2(TRACE_NORMAL, CNCMDATAINTERFACE_RUNL, "State=%x, status=%d", iIfState, iStatus.Int());

    if (KErrNone == iStatus.Int())

        {

        iLdd.AlternateDeviceStatusNotify(iStatus, iIfState);

        SetActive();

        if (iIfState & KUsbAlternateSetting)

            {

            TInt ret = KErrNone;

            iAltSetting = iIfState & ~KUsbAlternateSetting;

            if (KAltSetting1 == iAltSetting)

                {

                ret = iLdd.StartNextOutAlternateSetting(ETrue);

                if (KAltSetting1 == ret)

                    {

                    iEngine.HandleAltSetting(iAltSetting);

                    }

                else

                    {

                    iEngine.DataError(ret);

                    }

                }

            else

                {

                iEngine.HandleAltSetting(iAltSetting);

                ret = iLdd.StartNextOutAlternateSetting(ETrue);

                if (KAltSetting0 != ret)

                    {

                    iEngine.DataError(ret);

                    }

                }

            }

        }

    else

        {

        iEngine.DataError(iStatus.Int());

        }

    }

/**

 * AO cancel.

 */

void CNcmDataInterface::DoCancel()

    {

    iLdd.AlternateDeviceStatusNotifyCancel();

    }

/**

 * Get Connection Speed. (NB. Upstream's is the same as downstream's).

 */

TInt CNcmDataInterface::GetSpeed(TInt& aSpeed)

    {

    const TInt KHighSpeed = 480 * 1024 * 1024;

    const TInt KFullSpeed = 12 * 1024 * 1024;

    if (iLdd.CurrentlyUsingHighSpeed())

        {

        aSpeed = KHighSpeed;

        }

    else

        {

        aSpeed = KFullSpeed;

        }

    return KErrNone;

    }

/**

 * Get Ntb Input Size.

 */

TInt CNcmDataInterface::GetNtbInputSize(TDes8& aSize)

    {

    const TUint KNtbIntputSizeLength = 4;

    aSize.SetLength(KNtbIntputSizeLength);

    LittleEndian::Put32(&aSize[0], iSender->NtbInMaxSize());

    return KErrNone;

    }

/**

 * Set Ntb Input Size.

 */

TInt CNcmDataInterface::SetNtbInputSize(TDesC8& aSize)

    {

    TInt size = LittleEndian::Get32(aSize.Ptr());

    return iSender->SetNtbInMaxSize(size, KAltSetting0==iAltSetting);

    }

/**

 * Get Ntb Parameter.

 */

TInt CNcmDataInterface::GetNtbParam(TDes8& aParamBuf)

    {

    TNcmNtbInParam  param;

    iSender->GetNtbParam(param);

    const TUint32 KNtbParamLength = 0x001C;

    const TUint32 KNtbFormat = 0x0001;

    const TUint   KNtbParamLengthOffset = 0;                               //0

    const TUint   KNtbFormatOffset = KNtbParamLengthOffset + 2;            //2

    const TUint   KNtbInMaxSizeOffset = KNtbFormatOffset + 2;              //4

    const TUint   KNtbInDivisorOffset = KNtbInMaxSizeOffset + 4;           //8

    const TUint   KNtbInPayloadRemainderOffset = KNtbInDivisorOffset + 2;  //10

    const TUint   KNtbInAlignmentOffset = KNtbInPayloadRemainderOffset + 2;//12

    const TUint   KNtbOutMaxSizeOffset = KNtbInAlignmentOffset + 4;        //16

    const TUint   KNtbOutDivisorOffset = KNtbOutMaxSizeOffset + 4;         //20

    const TUint   KNtbOutPayloadRemainderOffset = KNtbOutDivisorOffset + 2;//22

    const TUint   KNtbOutAlignmentOffset = KNtbOutPayloadRemainderOffset + 2;//24

    aParamBuf.FillZ(KNtbParamLength);

    LittleEndian::Put16(&aParamBuf[KNtbParamLengthOffset], KNtbParamLength);

    LittleEndian::Put16(&aParamBuf[KNtbFormatOffset], KNtbFormat);

    LittleEndian::Put32(&aParamBuf[KNtbInMaxSizeOffset], param.iNtbInMaxSize);

    LittleEndian::Put16(&aParamBuf[KNtbInDivisorOffset], param.iNdpInDivisor);

    LittleEndian::Put16(&aParamBuf[KNtbInPayloadRemainderOffset], param.iNdpInPayloadRemainder);

    LittleEndian::Put16(&aParamBuf[KNtbInAlignmentOffset], param.iNdpInAlignment);

    //Tricky way: copy the Sender's parameter as the Receiver's.

    LittleEndian::Put32(&aParamBuf[KNtbOutMaxSizeOffset], iReceiver->NtbOutMaxSize());

    LittleEndian::Put16(&aParamBuf[KNtbOutDivisorOffset], param.iNdpInDivisor);

    LittleEndian::Put16(&aParamBuf[KNtbOutPayloadRemainderOffset], param.iNdpInPayloadRemainder);

    LittleEndian::Put16(&aParamBuf[KNtbOutAlignmentOffset], param.iNdpInAlignment);

    return KErrNone;

    }

TInt CNcmDataInterface::SetInEpBufferSize(TUint aSize)

    {

    return iSender->SetInEpBufferSize(aSize);

    }