/*
* 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:
* implementation of NCM communication interface class 
*
*/


#include <es_sock.h>
#include "ncmcommunicationinterface.h"
#include "ncmnotificationdescriptor.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "ncmcommunicationinterfaceTraces.h"
#endif



const TUint KUsbRequestLengthIdx = 6;
const TUint KUsbRequestTypeIdx = 1;
const TInt  KIntEndpoint = 1;
const TInt  KNotificationRequestType = 0xA1;


#if defined(_DEBUG)
_LIT(KNcmCommInterfacePanic, "UsbNcmComm"); // must be <=16 chars
#endif


// Panic codes
enum TNcmCommPanicCode
    {
    ENcmCommWrongSetupLength = 1,
    ENcmCommWrongDataLength,
    ENcmCommWriteError,
    ENcmCMEndMark
    };


// ======== MEMBER FUNCTIONS ========
//

CNcmCommunicationInterface::CNcmCommunicationInterface(MNcmControlObserver& aEngine, RDevUsbcScClient& aLdd) : CActive(CActive::EPriorityHigh),
                            iEngine(aEngine), iPort(aLdd)
    {
    CActiveScheduler::Add(this);
    }

void CNcmCommunicationInterface::ConstructL()
    {
    iSenderAndReceiver = CNcmCommInterfaceSenderAndReceiver::NewL(iPort, *this);
    }

CNcmCommunicationInterface* CNcmCommunicationInterface::NewL(MNcmControlObserver& aEngine, RDevUsbcScClient& aLdd)
    {
    OstTraceFunctionEntry0( CNCMCOMMUNICATIONINTERFACE_NEWL_ENTRY );
    CNcmCommunicationInterface *self=new (ELeave) CNcmCommunicationInterface(aEngine, aLdd);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();
    OstTraceFunctionExit0( CNCMCOMMUNICATIONINTERFACE_NEWL_EXIT );
    return self;
    }

CNcmCommunicationInterface::~CNcmCommunicationInterface()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_CNCMCOMMUNICATIONINTERFACE_ENTRY, this );
    
    Cancel();
    delete iSenderAndReceiver;
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_CNCMCOMMUNICATIONINTERFACE_EXIT, this );
    }

//
//Start the control channel of NCM
//
TInt CNcmCommunicationInterface::Start()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_START_ENTRY, this );
    if (iStarted)
        {
        OstTrace0( TRACE_WARNING, CNCMCOMMUNICATIONINTERFACE_START, "CNcmCommunicationInterface, already started!" );        
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_START_EXIT, this );
        return KErrInUse;
        }

    TInt ret = GetInterfaceNumber();
    if (ret != KErrNone)
        {        
        OstTrace1( TRACE_FATAL, CNCMCOMMUNICATIONINTERFACE_START1, "GetInterfaceNumber failed ret=%d", ret);
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_START_EXIT_DUP1, this );
        return ret;
        }
    
    iStarted = ETrue;
    iRWState = EStateInitial;

    iSenderAndReceiver->Start();

    //force a call to RunL
    SetActive();
    TRequestStatus* status=&iStatus;
    User::RequestComplete(status, KErrNone);
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_START_EXIT_DUP2, this );
    return KErrNone;
    }

//
//Listen on the ep0 to receive the NCM control message from host
//
void CNcmCommunicationInterface::ReadSetup()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_READSETUP_ENTRY, this );
    iRWState = EStateReadSetup;
    iRequestType = 0;
    iDataStageLength = 0;
    TInt ret = iSenderAndReceiver->Read(iStatus, iSetupPacket, KSetupPacketLength);

    if (ret != KErrNone)
        {
        OstTrace1( TRACE_FATAL, CNCMCOMMUNICATIONINTERFACE_READSETUP, "read setup packet error %d", ret);        
        ControlMsgError(EInternalError);
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_READSETUP_EXIT, this );
        return;
        }
    SetActive();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_READSETUP_EXIT_DUP1, this );
    }


//
//decode the setup packet to get command information.
//
void CNcmCommunicationInterface::DecodeSetup()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_DECODESETUP_ENTRY, this );
    
    __ASSERT_DEBUG(iSetupPacket.Length()==KSetupPacketLength, 
        User::Panic(KNcmCommInterfacePanic, ENcmCommWrongSetupLength));
		
    iRequestType = iSetupPacket[KUsbRequestTypeIdx];
    iDataStageLength = LittleEndian::Get16(&iSetupPacket[KUsbRequestLengthIdx]);
	
    switch (iRequestType)
        {
        case EGetNtbParameters:	
            if (iDataStageLength != KNtbParamStructLength)
                {
                ControlMsgError(EInvalidLengthToRead);
                break;
                }
            iEngine.HandleGetNtbParam(iDataBuffer);
            __ASSERT_DEBUG(iDataBuffer.Length()==KNtbParamStructLength, 
                User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));			
            WriteDataIn();
            break;
          
        case EGetNtbInputSize:
            if (iDataStageLength != KNtbInputSizeStructLength)
                {
                ControlMsgError(EInvalidLengthToRead);
                break;
                }			
            iEngine.HandleGetNtbInputSize(iDataBuffer);
            __ASSERT_DEBUG(iDataBuffer.Length()==KNtbInputSizeStructLength, 
                User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));						
            WriteDataIn();
            break;
			
        case ESetNtbInputSize:
            if (iDataStageLength != KNtbInputSizeStructLength)
                {
                ControlMsgError(EInvalidLengthToRead);
                break;
                }		
            ReadDataOut();
            break;
        default:
            TInt ret = iPort.EndpointZeroRequestError();
            OstTrace1( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_DECODESETUP, "unsupport request, halt endpoint with EndpointZeroRequestError %d", ret);
            ReadSetup();
            break;
        }
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_DECODESETUP_EXIT, this );
    }



//
//Read the raw data of a control request message from host
//
void CNcmCommunicationInterface::ReadDataOut()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_READDATAOUT_ENTRY, this );
    iRWState = EStateReadDataout;
    iSenderAndReceiver->Read(iStatus, iDataBuffer, iDataStageLength);
    SetActive();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_READDATAOUT_EXIT, this );
    }




//
//Parse the data out from host to specific NCM control message
//
void CNcmCommunicationInterface::ParseDataOut()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT_ENTRY, this );

    __ASSERT_DEBUG(iDataBuffer.Length()>0, 
        User::Panic(KNcmCommInterfacePanic, ENcmCommWrongDataLength));			

    TInt ret = KErrNone;
    switch (iRequestType)
        {
        case ESetNtbInputSize:
            ret = iEngine.HandleSetNtbInputSize(iDataBuffer);    
            break;
        default:
            ret = KErrNotSupported;
            break;
        }
    
    if (ret == KErrNone)
        {
        iPort.SendEp0StatusPacket();
        }
    else
        {
        OstTrace1( TRACE_WARNING, CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT, "handle request iRequestType error %d stall endpoint", ret);
        iPort.EndpointZeroRequestError();
        }
    ReadSetup();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_PARSEDATAOUT_EXIT, this );
    }
    
//
// send connection status notification, aConnected = ETrue if connection up, otherwise EFalse if connection discnnected
//
TInt CNcmCommunicationInterface::SendConnectionNotification(TBool aConnected)
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_SENDCONNECTIONNOTIFICATION_ENTRY, this );
    const TUint8 KConnectionNotificationCode = 0x00;
    const TUint16 KConnectedCode = 0x0001;
    const TUint16 KDisconnectCode = 0x0000;    

    TUSBNotificationNetworkConnection netNotify;
    netNotify.iRequestType = KNotificationRequestType;
    netNotify.iNotification = KConnectionNotificationCode;
    netNotify.iValue = (aConnected)?KConnectedCode:KDisconnectCode; 
    netNotify.iIndex = iInterfaceNumber;
    netNotify.iLength = 0;

    return WriteInterruptData(KIntEndpoint, netNotify.Des(), 
        netNotify.Des().Length());            
    }

//
// send speed notification
//
TInt CNcmCommunicationInterface::SendSpeedNotification(TInt aUSBitRate, TInt aDSBitRate)
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_SENDSPEEDNOTIFICATION_ENTRY, this );
    const TUint8 KSpeedNotificationCode = 0x2A;
        
    TUSBNotificationConnectionSpeedChange speedNotify;
    speedNotify.iRequestType = KNotificationRequestType;
    speedNotify.iNotification = KSpeedNotificationCode;
    speedNotify.iValue = 0x00; 
    speedNotify.iIndex = iInterfaceNumber;
    speedNotify.iLength = 0x08;
    speedNotify.iUSBitRate = aUSBitRate;
    speedNotify.iDSBitRate = aDSBitRate;

    return WriteInterruptData(KIntEndpoint, speedNotify.Des(), 
        speedNotify.Des().Length());    
    }


//
//According to the receving request message, send back a response to the host
//
void CNcmCommunicationInterface::WriteDataIn()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_WRITEDATAIN_ENTRY, this );

    iRWState = EStateWriteDatain;
    TInt ret = iSenderAndReceiver->Write(iStatus, iDataBuffer, iDataBuffer.Length());
    __ASSERT_DEBUG(ret==KErrNone, User::Panic(KNcmCommInterfacePanic, ENcmCommWriteError));		
    SetActive();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEDATAIN_EXIT, this );
    }

//
//Cancel the outgoing request
//
void CNcmCommunicationInterface::DoCancel()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_DOCANCEL_ENTRY, this );
    TRequestStatus* status = &iStatus;    
    User::RequestComplete(status, KErrCancel); 
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_DOCANCEL_EXIT, this );
    }

//
//Stop the control channel to stop the NCM
//
void CNcmCommunicationInterface::Stop()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_STOP_ENTRY, this );
    iStarted = EFalse;
    iSenderAndReceiver->Stop();
    Cancel();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_STOP_EXIT, this );
    }

//
//AO RunL
//
void CNcmCommunicationInterface::RunL()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_RUNL_ENTRY, this );
    if(iStatus.Int() != KErrNone)
        {
        if (KErrCancel == iStatus.Int() )
            {
            }
        else
            {
            ControlMsgError(EInternalError);
            }
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_RUNL_EXIT, this );
        return;
        }

    switch(iRWState)
        {
        case EStateInitial:
            {
            ReadSetup();
            break;
            }
            
        case EStateReadSetup:
            {
            DecodeSetup();
            break;
            }
            
        case EStateReadDataout:
            {
            ParseDataOut();
            break;
            }

        case EStateWriteDatain:
            {
            ReadSetup();
            break;
            }    
        }
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_RUNL_EXIT_DUP1, this );
    }

  
//
//Any fatal error occurs when reading/sending a NCM control message via USB interface
//
void CNcmCommunicationInterface::ControlMsgError(TNcmCommErrorCode aCode)
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_CONTROLMSGERROR_ENTRY, this );
    OstTrace1( TRACE_NORMAL, CNCMCOMMUNICATIONINTERFACE_CONTROLMSGERROR, "CNcmCommunicationInterface, Handle Ncm Control Message with err=%d", aCode);
    
    // Stall bus, there's nothing else we can do 
    iPort.EndpointZeroRequestError();  
    iEngine.ControlError(aCode);
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_CONTROLMSGERROR_EXIT, this );
    }


TInt CNcmCommunicationInterface::WriteInterruptData(TInt aEndPoint, 
                               TDesC8& aDes, 
                               TInt aLength)

    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_ENTRY, this );

    TInt ret;
    RTimer timer;
    ret = timer.CreateLocal();
    if ( ret )
        {
        OstTrace1( TRACE_FATAL, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA, "\ttimer.CreateLocal = %d- returning", ret);        
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT, this );
        return ret;
        }
    TRequestStatus status;
    TRequestStatus timerStatus;

    TEndpointBuffer epBuffer;
    ret = iPort.OpenEndpoint(epBuffer, aEndPoint);
    if (ret != KErrNone)
        {
        timer.Close();
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP1, this );
        return ret;
        }

    TAny *buf;
    TUint size;
    ret = epBuffer.GetInBufferRange(buf, size);
    if (ret != KErrNone)
        {        
        timer.Close();
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP2, this );
        return ret;
        }
    else if (size < aLength)
        {
        timer.Close();
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP3, this );
        return KErrArgument;
        }
    
    TPtr8 writeBuf((TUint8 *)buf, size);
    writeBuf.Copy(aDes.Ptr(), aLength);
    ret = epBuffer.WriteBuffer(buf, writeBuf.Size(), ETrue, status);
    if (ret != KErrNone)
        {
        timer.Close();
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP4, this );
        return ret;
        }

    const TInt KWriteDataTimeout = 1000000;
    timer.After(timerStatus, KWriteDataTimeout);
    User::WaitForRequest(status, timerStatus);
    if ( timerStatus != KRequestPending )
        {
        // Timeout occurred, silently ignore error condition.
        // Assuming that the line has been disconnected
        OstTrace0( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA1, "CNcmCommunicationInterface::WriteInterruptData() - Timeout occurred");
        iPort.WriteCancel(epBuffer.BufferNumber());
        User::WaitForRequest(status);
        ret = timerStatus.Int();
        }
    else
        {
        OstTrace0( TRACE_ERROR, CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA2, "CNcmCommunicationInterface::WriteInterruptData() - Write completed");
        timer.Cancel();
        User::WaitForRequest(timerStatus);
        ret = status.Int();
        }
    
    epBuffer.Close();
    timer.Close();
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_WRITEINTERRUPTDATA_EXIT_DUP5, this );
    return ret;
    }


//
// Get interface number
//
TInt CNcmCommunicationInterface::GetInterfaceNumber()
    {
    OstTraceFunctionEntry1( CNCMCOMMUNICATIONINTERFACE_GETINTERFACENUMBER_ENTRY, this );

    TInt interfaceSize = 0;
    // 2 is where the interface number is, according to the LDD API
    const TInt intNumOffsetInDes = 2;

    // 0 means the main interface in the LDD API
    TInt res = iPort.GetInterfaceDescriptorSize(0, interfaceSize);

    if ( res )
        {
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_GETINTERFACENUMBER_EXIT, this );
        return res;
        }

    HBufC8* interfaceBuf = HBufC8::New(interfaceSize);
    if ( !interfaceBuf )
        {
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_GETINTERFACENUMBER_EXIT_DUP1, this );
        return KErrNoMemory;
        }

    TPtr8 interfacePtr = interfaceBuf->Des();
    interfacePtr.SetLength(0);
    // 0 means the main interface in the LDD API
    res = iPort.GetInterfaceDescriptor(0, interfacePtr); 

    if ( res )
        {
        delete interfaceBuf;
        OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_GETINTERFACENUMBER_EXIT_DUP2, this );
        return res;
        }

    const TUint8* buffer = reinterpret_cast<const TUint8*>(interfacePtr.Ptr());
    iInterfaceNumber = buffer[intNumOffsetInDes]; 

    delete interfaceBuf;
    OstTraceFunctionExit1( CNCMCOMMUNICATIONINTERFACE_GETINTERFACENUMBER_EXIT_DUP3, this );
    return KErrNone;
    }