/*

* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

#include "cusbpnusbreceiver.h"

#include "cusbpnisasender.h"        // For sending messages to ISA

#include "cusbpnpacket.h"           // For packet buffers

#include "usbpndefinitions.h"       // For constants

#include "usbpntrace.h"             // For tracing

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cusbpnusbreceiverTraces.h"

#endif

#include <d32usbc.h>                // For RDevUsbcClient

#include <pn_const.h>               // For header size

#include <phonetisi.h>              // For Phonet definitions

#ifndef NCP_COMMON_BRIDGE_FAMILY

#include <test_serverisi.h>         // For APE Test Server message ID

#include <iscnokiadefinitions.h>    // For APE Test Server channel ID

#endif /* NCP_COMMON_BRIDGE_FAMILY */

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

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::CUsbPnUsbReceiver

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CUsbPnUsbReceiver::CUsbPnUsbReceiver( RDevUsbcClient& aLdd )

    :CActive( CActive::EPriorityStandard )

    , iLdd( aLdd )

    , iRecvPtr( NULL, NULL )

    , iStorage( NULL )

    {

    OstTrace1( TRACE_NORMAL, CUSBPNUSBRECEIVER_CUSBPNUSBRECEIVER_ENTRY, "CUsbPnUsbReceiver::CUsbPnUsbReceiver;aLdd=%x", ( TUint )&( aLdd ) );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::CUsbPnUsbReceiver( aLdd:0x%x )" ), &aLdd ) );

    CActiveScheduler::Add(this);

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CUSBPNUSBRECEIVER_EXIT, "CUsbPnUsbReceiver::CUsbPnUsbReceiver - return" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::CUsbPnUsbReceiver() - return" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::ConstructL( RIscApi& aIscApi )

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CONSTRUCTL_ENTRY, "CUsbPnUsbReceiver::ConstructL" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructL()" ) ) );

    iIsaSender = CUsbPnIsaSender::NewL( *this, aIscApi );

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CONSTRUCTL_EXIT, "CUsbPnUsbReceiver::ConstructL - return void" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructL() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CUsbPnUsbReceiver* CUsbPnUsbReceiver::NewL( RDevUsbcClient& aLdd, RIscApi& aIscApi )

    {

    OstTraceExt2( TRACE_NORMAL, CUSBPNUSBRECEIVER_NEWL_ENTRY, "CUsbPnUsbReceiver::NewL;aLdd=%x;aIscApi=%x", ( TUint )&( aLdd ), ( TUint )&( aIscApi ) );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::NewL( aLdd:0x%x, aIscApi:0x%x )" ), &aLdd, &aIscApi ) );

    CUsbPnUsbReceiver* self = new( ELeave ) CUsbPnUsbReceiver( aLdd );

    CleanupStack::PushL( self );

    self->ConstructL( aIscApi );

    CleanupStack::Pop( self );

    OstTrace1( TRACE_NORMAL, CUSBPNUSBRECEIVER_NEWL_EXIT, "CUsbPnUsbReceiver::NewL - return;self=%x", self );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::NewL() - return 0x%x" ), self ) );

    return self;

    }

// Destructor

CUsbPnUsbReceiver::~CUsbPnUsbReceiver()

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CUSBPNUSBRECEIVER_DESTRUCTOR_ENTRY, "CUsbPnUsbReceiver::~CUsbPnUsbReceiver" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::~CUsbPnUsbReceiver()" ) ) );

    Cancel();

    if( iIsaSender )

        {

        delete iIsaSender;

        }

    iIsaSender = NULL;

    iPacket = NULL;

    if( iStorage )

        {

        delete iStorage;

        }

    iStorage = NULL;

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CUSBPNUSBRECEIVER_DESTRUCTOR_EXIT, "CUsbPnUsbReceiver::~CUsbPnUsbReceiver - return" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::~CUsbPnUsbReceiver() - return" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::DoCancel

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::DoCancel( )

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_DOCANCEL_ENTRY, "CUsbPnUsbReceiver::DoCancel" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::DoCancel()" ) ) );

    iLdd.ReadCancel( EEndpoint2 );

#ifdef _DEBUG

    TRAPD(err, iPacket->ReleaseL());

#elif defined OST_TRACE_COMPILER_IN_USE

    TRAPD(err, iPacket->ReleaseL());

#else

    TRAP_IGNORE(iPacket->ReleaseL());

#endif

    OstTrace1( TRACE_NORMAL, CUSBPNUSBRECEIVER_DOCANCEL, "CUsbPnUsbReceiver::DoCancel - err=%d", err );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::DoCancel() - err=%d" ), err ) );

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_DOCANCEL_EXIT, "CUsbPnUsbReceiver::DoCancel - return void" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::DoCancel() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::RunL

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::RunL( )

    {

    A_TRACE( ( _T( "CUsbPnUsbReceiver::RunL() iStatus:%d" ), iStatus.Int() ) );

    User::LeaveIfError( iStatus.Int() );

    ConstructMessageL();

    if( iMessageComplete )

        {

        iIsaSender->AddPacketToSendingQueue( *iPacket );

        SetMessageComplete( EFalse );

        SetByteCount( NULL );

        SetMessageLength( NULL );

        Receive( ETrue );

        }

    A_TRACE( ( _T( "CUsbPnUsbReceiver::RunL() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::SetMessageComplete

// -----------------------------------------------------------------------------

void CUsbPnUsbReceiver::SetMessageComplete( const TBool aMsgComplete )

    {

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetMessageComplete() aMsgComplete:%d" ), aMsgComplete ) );

    iMessageComplete = aMsgComplete;

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetMessageComplete() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::SetByteCount

// -----------------------------------------------------------------------------

void CUsbPnUsbReceiver::SetByteCount( const TUint aByteCount )

    {

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetByteCount() aByteCount:%d" ), aByteCount ) );

    iByteCount = aByteCount;

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetByteCount() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::SetMessageLength

// -----------------------------------------------------------------------------

void CUsbPnUsbReceiver::SetMessageLength( const TUint aMessageLength )

    {

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetMessageLength() aMessageLength:%d" ), aMessageLength ) );

    iMessageLength = aMessageLength;

    A_TRACE( ( _T( "CUsbPnUsbReceiver::SetMessageLength() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::RunError

// -----------------------------------------------------------------------------

//

TInt CUsbPnUsbReceiver::RunError( TInt aError )

    {

    A_TRACE( ( _T( "CUsbPnUsbReceiver::RunError(aError:%d)" ), aError ) );

    switch( aError )

        {

        case KErrUsbDriverBase:

        case KErrUsbInterfaceNotReady:

        case KErrUsbEpNotInInterface:

        case KErrUsbEpBadDirection:

        case KErrUsbTransferSize:

        case KErrUsbDeviceNotConfigured:

        case KErrUsbBadEndpoint:

        case KErrUsbDeviceClosing:

        case KErrUsbInterfaceChange:

        case KErrUsbCableDetached:

        case KErrUsbDeviceBusReset:

        case KErrUsbEpNotReady:

            {

            OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RUNERROR, "CUsbPnUsbReceiver::RunError - Cable detached!" );

            C_TRACE( ( _T( "CUsbPnUsbReceiver::RunError - Cable detached!" )));

            break;

            }

        default:

            {

            TRACE_ASSERT_ALWAYS;           

            break;

            }

        }

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RUNERROR_EXIT, "CUsbPnUsbReceiver::RunError - return" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::RunError() - return" ) ) );

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::Receive

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::Receive( TBool )

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RECEIVE_ENTRY, "CUsbPnUsbReceiver::Receive" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::Receive()" )) );

    // iEnumerated flag is controlled by CUsbPnInterface. ETrue when altset1. EFalse if altset0 or cable disconnected.

    if( iEnumerated )

        {

        if(!IsActive())

            {

            TRAPD( err, iPacket = &iIsaSender->GetNextPacketL() );

            if(!err)

                {

                iRecvPtr.Set( iPacket->Buffer().Des() );

                iLdd.ReadUntilShort( iStatus, EEndpoint2, iRecvPtr );

                OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RECEIVE, "CUsbPnUsbReceiver::Receive - Receiving" );

                C_TRACE( ( _T( "CUsbPnUsbReceiver::Receive - Receiving" )) );

                SetActive();

                }

            else

                {

                OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RECEIVE_DUP1, "CUsbPnUsbReceiver::Receive - Sender tells when to continue" );

                C_TRACE( ( _T( "CUsbPnUsbReceiver::Receive - Sender tells when to continue" )) );

                }

            }

        }

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_RECEIVE_EXIT, "CUsbPnUsbReceiver::Receive - return void" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::Receive() - return void" ) ) );

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::IsaSender

// -----------------------------------------------------------------------------

//

MUsbPnControlObserver* CUsbPnUsbReceiver::IsaSender()

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_ISASENDER_ENTRY, "CUsbPnUsbReceiver::IsaSender" );

    OstTrace1( TRACE_NORMAL, CUSBPNUSBRECEIVER_ISASENDER_EXIT, "CUsbPnUsbReceiver::IsaSender - return;MUsbPnControlObserver*=%x", (MUsbPnControlObserver*)iIsaSender );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::IsaSender()")));

    C_TRACE( ( _T( "CUsbPnUsbReceiver::IsaSender() - return MUsbPnControlObserver*: 0x%x"), (MUsbPnControlObserver*)iIsaSender ));

    return (MUsbPnControlObserver*)iIsaSender;

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::SetEnumerated

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::SetEnumerated( TBool aState )

    {

    OstTrace1( TRACE_NORMAL, CUSBPNUSBRECEIVER_SETENUMERATED_ENTRY, "CUsbPnUsbReceiver::SetEnumerated;aState=%d", aState );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::SetEnumerated( aState:%d)"), aState));

    iEnumerated = aState;

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_SETENUMERATED_EXIT, "CUsbPnUsbReceiver::SetEnumerated - return void" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::SetEnumerated() - return void")));

    }

// -----------------------------------------------------------------------------

// CUsbPnUsbReceiver::ConstructMessage

// Messages larger than max packet size must be constructed from multiple packets

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CUsbPnUsbReceiver::ConstructMessageL()

    {

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CONSTRUCTMESSAGEL_ENTRY, "CUsbPnUsbReceiver::ConstructMessageL" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage()" ) ) );

    TUint packetLength( iPacket->Buffer().Length() );

    E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - packetLength:%d" ), packetLength ) );

    // New message

    if( iByteCount == 0 )

        {

        TUint16 lsb(iRecvPtr[ISI_HEADER_OFFSET_LENGTH +1]);

        TUint16 msb(iRecvPtr[ISI_HEADER_OFFSET_LENGTH]);

        iMessageLength = ( lsb | ( msb<<8 ) );

        E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - iMessageLength:%d" ), iMessageLength ) );

        if( iMessageLength >= 4 )

            {

            iByteCount = packetLength;

            E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - New message. Received:%d"), iByteCount));

            if( ( PN_HEADER_SIZE + iMessageLength ) > packetLength )

                {

                E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - partial message. Receive more")));

                iStorage = HBufC8::NewL( iMessageLength + PN_HEADER_SIZE );

                TPtr8 tmp( iStorage->Des() );

                tmp.Append( iPacket->Buffer() );

                }

            }

        }

    // Appending to previous message

    else

        {

        iByteCount = iByteCount + packetLength;

        E_TRACE((_T("CUsbPnUsbReceiver::ConstructMessage - Append to previous part. iByteCount:%d"), iByteCount));

        TPtr8 tmp( iStorage->Des() );

        tmp.Append( iPacket->Buffer() );

        }

    // message ready to be sent

    if( iByteCount == ( iMessageLength + PN_HEADER_SIZE ) )

        {

        E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - message complete")));

        if( iByteCount > KPnPacketSize )

            {

            E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - realloc for whole message")));

            iPacket->ReallocBufferL( iMessageLength + PN_HEADER_SIZE );

            iRecvPtr.Set( iPacket->Buffer().Des() );

            iRecvPtr.Append( *iStorage );

            delete iStorage;

            iStorage = NULL;

            }

        // Converts the endianess of message length

        TUint8 tmp4(iRecvPtr[ISI_HEADER_OFFSET_LENGTH]);

        TUint8 tmp5(iRecvPtr[ISI_HEADER_OFFSET_LENGTH +1]);

        iRecvPtr[ISI_HEADER_OFFSET_LENGTH] = tmp5;

        iRecvPtr[ISI_HEADER_OFFSET_LENGTH +1] = tmp4;

#endif // #ifdef ISI_LENGTH_LITTLE_ENDIAN

#ifndef NCP_COMMON_BRIDGE_FAMILY

        // Message directly to APE Test Server.

        if( (iRecvPtr[ISI_HEADER_OFFSET_RESOURCEID] == PN_EPOC_TEST) &&

            (iRecvPtr[ISI_HEADER_OFFSET_MESSAGEID] == TS_SOS_FILE_WRITE_REQ ) )

            {

            E_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage - Message to APE Test Server")));

            iRecvPtr[ISI_HEADER_OFFSET_RECEIVERDEVICE] = PN_DEV_SOS;

            iRecvPtr[ISI_HEADER_OFFSET_RECEIVEROBJECT] = EIscNokiaTest;

            }

#endif // NCP_COMMON_BRIDGE_FAMILY 

        iMessageComplete = ETrue;

        }

    else

        {

        // Empty packet buffer and receive next packet to it.

        iPacket->ReleaseL();

        iRecvPtr.Set( iPacket->Buffer().Des() );

        iLdd.ReadUntilShort( iStatus, EEndpoint2, iRecvPtr );

        E_TRACE((_T("CUsbPnUsbReceiver::ConstructMessage - Receiving")));

        SetActive();

        }

    OstTrace0( TRACE_NORMAL, CUSBPNUSBRECEIVER_CONSTRUCTMESSAGEL_EXIT, "CUsbPnUsbReceiver::ConstructMessageL - return void" );

    C_TRACE( ( _T( "CUsbPnUsbReceiver::ConstructMessage() - return void" ) ) );

}    

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File