// Copyright (c) 2006-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 "cmtpusbconnection.h"

#include "cmtpusbepbase.h"

#include "mtpusbpanic.h"

#include "cmtpusbcontainer.h"

#include "mtpbuildoptions.hrh"

#include "mtpusbprotocolconstants.h"

#include <e32debug.h>

const TUint KUSBHeaderSize = 12;

#define UNUSED_VAR(a) (a)=(a)

/**

Destructor

*/

CMTPUsbEpBase::~CMTPUsbEpBase()

    {

    __FLOG(_L8("CMTPUsbEpBase::~CMTPUsbEpBase - Entry"));

    Cancel();

    iPacketBuffer.Close();

    __FLOG(_L8("CMTPUsbEpBase::~CMTPUsbEpBase - Exit"));

    __FLOG_CLOSE;

    }

/**

Provides the logical endpoint number of the endpoint.

@return The logical endpoint number. 

*/

TEndpointNumber CMTPUsbEpBase::EndpointNumber() const

    {

    return iConnection.EndpointNumber(iId);

    }

/**

Provides the internal endpoint identifier of the endpoint.

@return The internal endpoint identifier. 

*/

TUint CMTPUsbEpBase::Id() const

    {

    return iId;

    }

/**

Constructor

@param aId The internal endpoint identifier of the endpoint.

@param aPriority the priority of the active object assigned. 

@param aConnection MTP USB device class transport connection which controls 

the endpoint.

*/

CMTPUsbEpBase::CMTPUsbEpBase(TUint aId, TPriority aPriority, CMTPUsbConnection& aConnection) :

    CActive(aPriority),

    iId(aId),

    iReceiveChunkData(NULL, 0),

    iReceiveData(NULL, 0),

    iSendChunkData(NULL, 0),

    iSendData(NULL, 0),

    iIsFirstChunk(EFalse),

    iConnection(aConnection)

    {

    CActiveScheduler::Add(this);

    }

/**

Second phase constructor.

*/

#ifdef __FLOG_ACTIVE    

void CMTPUsbEpBase::ConstructL(const TDesC8& aComponentName)

#else

void CMTPUsbEpBase::ConstructL()

#endif

    {

    __FLOG_OPEN(KMTPSubsystem, aComponentName);

    __FLOG(_L8("CMTPUsbEpBase::ConstructL - Entry"));

    __FLOG(_L8("CMTPUsbEpBase::ConstructL - Exit"));

    }

/**

Sets the MaxPacketSize for the endpoint.

@param aSize The maximum packet size.

@leave One of the system wide error codes, if a processing failure occurs.

*/

void CMTPUsbEpBase::SetMaxPacketSizeL(TUint aSize)

	{

	__FLOG(_L8("CMTPUsbEpBase::SetMaxPacketSizeL - Entry"));

	iPacketSizeMax = aSize;

	__FLOG_VA((_L8("Endpoint %d maximum packetsize = %u"), iId, iPacketSizeMax));

	// Allocate the packet buffer.

    iPacketBuffer.ReAllocL(iPacketSizeMax);

    __FLOG(_L8("CMTPUsbEpBase::SetMaxPacketSizeL - Exit"));

	}    

/**

Creates a stall condition on the endpoint.

*/  

void CMTPUsbEpBase::Stall()

    {

    __FLOG(_L8("CMTPUsbEpBase::Stall - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    Cancel();

    RDevUsbcClient& ldd(Connection().Ldd());

    const TEndpointNumber number(EndpointNumber());

    TEndpointState state;

    ldd.EndpointStatus(number, state);

    __FLOG_VA((_L8("EndpointStatus = %d"), state));

    if (state != EEndpointStateStalled)

        {

        __FLOG_VA((_L8("Halting endpoint = %d"), number));

        ldd.HaltEndpoint(number);

        }

    SetStreamState(EStalled);

    __FLOG(_L8("CMTPUsbEpBase::Stall - Exit"));

    }

/**

Clears a stall condition on the endpoint.

*/    

void CMTPUsbEpBase::StallClear()

    {

    __FLOG(_L8("CMTPUsbEpBase::StallClear - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    RDevUsbcClient& ldd(Connection().Ldd());

    const TEndpointNumber number(EndpointNumber());

    TEndpointState state;

    ldd.EndpointStatus(number, state);

    __FLOG_VA((_L8("EndpointStatus = %d"), state));

    if (state != EEndpointStateNotStalled)

        {

        __FLOG_VA((_L8("Clearing halt on endpoint = %d"), number));

        Connection().Ldd().ClearHaltEndpoint(number);

        }

    SetStreamState(EIdle);

    __FLOG(_L8("CMTPUsbEpBase::StallClear - Exit"));

    }

/**

Indicates whether the endpoint is currently in a stalled condition.

@return ETrue if the endpoint is in a stalled condition, otherwise EFalse.

*/

TBool CMTPUsbEpBase::Stalled() const

    {

    return (iState == EStalled);

    }

/**

Determines the relative order of the two endpoints based on their IDs. 

@return Zero, if the two objects are equal; a negative value, if the first 

endpoint's ID is less than the second, or; a positive value, if the first 

endpoint's ID is greater than the second.

*/    

TInt CMTPUsbEpBase::LinearOrder(const CMTPUsbEpBase& aL, const CMTPUsbEpBase& aR)

    {

    return (aL.iId - aR.iId);

    }

/**

Provides the MTP USB device class transport connection which controls the 

endpoint.

@return The MTP USB device class transport connection. 

*/

CMTPUsbConnection& CMTPUsbEpBase::Connection() const

    {

    return iConnection;

    }

/**

Forces the completion of a transfer in progress. This will

reset the data streams without having to stall the endpoints.

This is needed because Windows does not expect endpoints to 

stall on error conditions.

@param aReason error code describing the reason for cancelling.

@leave Any of the system wide error codes.

*/

void CMTPUsbEpBase::CancelReceiveL(TInt aReason)

	{

	__FLOG(_L8("CMTPUsbEpBase::CancelReceiveL - Entry"));

    if (DataStreamDirection() == EReceivingState)

	    {

		__FLOG(_L8("Cancel in EReceivingState"));            

	    // Cancel any outstanding request.

    	Cancel();  

        // Notify the connection and reset the receive data stream.

        ResetReceiveDataStream();

        ReceiveDataCompleteL(aReason, *iReceiveDataSink);

        // Flush incoming data, otherwise device and PC may get out of sync

        FlushRxDataL();

	    }

    __FLOG(_L8("CMTPUsbEpBase::CancelReceiveL - Exit"));	

	}

/**

Forces the completion of a transfer in progress. This will

reset the data streams without having to stall the endpoints.

This is needed because Windows does not expect endpoints to 

stall on error conditions.

@param aReason error code describing the reason for cancelling.

@leave Any of the system wide error codes.

*/

void CMTPUsbEpBase::CancelSendL(TInt aReason)

	{

	__FLOG(_L8("CMTPUsbEpBase::CancelSendL - Entry"));

	if (DataStreamDirection() == ESendingState)

		{

 		__FLOG(_L8("Cancel in ESendingState"));

 		// Cancel any outstanding request.

    	Cancel();  

        // Notify the connection and reset the send data stream.

        ResetSendDataStream();

        SendDataCompleteL(aReason, *iSendDataSource);

		}

	__FLOG(_L8("CMTPUsbEpBase::CancelSendL - Exit"));

	}

/**

Initiates an asynchronous data receive sequence. 

@param aSink The receive data sink buffer.

@leave One of the system wide error codes, if a processing failure occurs.

*/

void CMTPUsbEpBase::ReceiveDataL(MMTPType& aSink)

    {

    __FLOG(_L8("CMTPUsbEpBase::ReceiveDataL - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    if(iState != EIdle)

      {

    	Cancel();

      }

    __ASSERT_DEBUG(iState == EIdle, Panic(EMTPUsbBadState));

    iReceiveDataSink    = &aSink;

    iReceiveDataCommit  = iReceiveDataSink->CommitRequired();

    SetStreamState(EReceiveInitialising);

    InitiateFirstChunkReceiveL(); 

    __FLOG_VA((_L8("CMTPUsbEpBase state on exit = 0x%08X"), iState));

    __FLOG(_L8("CMTPUsbEpBase::ReceiveDataL - Exit")); 

    }

/**

Resumes a halted data receive sequence.

@param aSink The receive data sink buffer.

@leave One of the system wide error codes, if a processing failure occurs.

*/

void CMTPUsbEpBase::ResumeReceiveDataL(MMTPType& aSink)

	{

	__FLOG(_L8("CMTPUsbEpBase::ResumeReceiveDataL - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    __ASSERT_DEBUG(iState == EIdle, Panic(EMTPUsbBadState));

    iReceiveDataSink    = &aSink;

    iReceiveDataCommit  = iReceiveDataSink->CommitRequired();

    iChunkStatus = iReceiveDataSink->NextWriteChunk(iReceiveChunkData);

    // The first chunk is going to be read.

    iReceiveData.Set(iReceiveChunkData);

    __FLOG_VA((_L8("Issuing ReadUntilShort request on endpoint %d"), EndpointNumber()));

    __FLOG_VA((_L8("Receive chunk capacity = %d bytes, length = %d bytes"), iReceiveChunkData.MaxLength(), iReceiveChunkData.Length()));

    __FLOG_VA((_L8("Chunk status = %d"), iChunkStatus)); 

    Connection().Ldd().ReadUntilShort(iStatus, EndpointNumber(), iReceiveData);

    SetStreamState(EReceiveInProgress);

    SetActive();

    __FLOG(_L8("CMTPUsbEpBase::ResumeReceiveDataL - Exit")); 

	}

/**

Signals the data transfer controller that an asynchronous data receive 

sequence has completed.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPUsb 2 In debug builds only, if the derived class has not fully 

implemented the receive data path.

*/

void CMTPUsbEpBase::ReceiveDataCompleteL(TInt /*aError*/, MMTPType& /*aSink*/)

    {

    __FLOG(_L8("CMTPUsbEpBase::ReceiveDataCompleteL - Entry"));

    __DEBUG_ONLY(Panic(EMTPUsbNotSupported));

    __FLOG(_L8("CMTPUsbEpBase::ReceiveDataCompleteL - Exit"));

    }

/**

Initiates an asynchronous data send sequence. 

@param aSource The send data source buffer.

@leave One of the system wide error codes, if a processing failure occurs.

*/

void CMTPUsbEpBase::SendDataL(const MMTPType& aSource)

    {

    __FLOG(_L8("CMTPUsbEpBase::SendDataL - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    __ASSERT_DEBUG(iState == EIdle, Panic(EMTPUsbBadState));

    iSendDataSource = &aSource;

    SetStreamState(ESendInitialising);

    ProcessSendDataStreamL();

    __FLOG_VA((_L8("CMTPUsbEpBase state on exit = 0x%08X"), iState));

    __FLOG(_L8("CMTPUsbEpBase::SendDataL - Exit"));

    }

/**

Signals tthe data transfer controller that an asynchronous data send sequence 

has completed.

@leave One of the system wide error codes, if a processing failure occurs.

@panic MTPUsb 2 In debug builds only, if the derived class has not fully 

implemented the send data path.

*/

void CMTPUsbEpBase::SendDataCompleteL(TInt /*aError*/, const MMTPType& /*aSource*/)

    {

    __FLOG(_L8("CMTPUsbEpBase::SendDataCompleteL - Entry"));

    __DEBUG_ONLY(Panic(EMTPUsbNotSupported));

    __FLOG(_L8("CMTPUsbEpBase::SendDataCompleteL - Exit"));

    }

void CMTPUsbEpBase::DoCancel()

    {

    __FLOG(_L8("CMTPUsbEpBase::DoCancel - Entry"));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    switch (iState & EStateDirection)

        {

    case EReceivingState:

        __FLOG_VA((_L8("Issuing ReadCancel on endpoint %d"), EndpointNumber()));

        Connection().Ldd().ReadCancel(EndpointNumber());

        ResetReceiveDataStream();

        break;

    case ESendingState:    

        __FLOG_VA((_L8("Issuing WriteCancel on endpoint %d"), EndpointNumber()));

        Connection().Ldd().WriteCancel(EndpointNumber());

        ResetSendDataStream();

        break;

    default:

        break;

        }

    __FLOG(_L8("CMTPUsbEpBase::DoCancel - Exit"));

    }

TInt CMTPUsbEpBase::RunError(TInt aError)

    {

    __FLOG(_L8("CMTPUsbEpBase::RunError - Entry"));

    __FLOG_VA((_L8("Error = %d"), aError));  

    // Cancel any outstanding request.

    Cancel();  

    // Notify the protocol layer of the error.

    TInt32 streamDirection = DataStreamDirection();

    if (streamDirection == EReceivingState)

	    {

		__FLOG(_L8("Error in EReceivingState"));            

        // Notify the connection and reset the receive data stream.

        MMTPType& data(*iReceiveDataSink);

        ResetReceiveDataStream();

        TRAPD(err, ReceiveDataCompleteL(aError, data));

        UNUSED_VAR(err);

	    }

	else if (streamDirection == ESendingState)

		{

		__FLOG(_L8("Error in ESendingState"));

        // Notify the connection and reset the send data stream.

        const MMTPType& data(*iSendDataSource);

        ResetSendDataStream();

        TRAPD(err, SendDataCompleteL(aError, data));

        UNUSED_VAR(err);

		}

    __FLOG(_L8("CMTPUsbEpBase::RunError - Exit"));

    return KErrNone;

    }

void CMTPUsbEpBase::RunL()

    {

    __FLOG(_L8("CMTPUsbEpBase::RunL - Entry"));

    __FLOG_VA((_L8("Current endpoint is %d"), EndpointNumber()));

    __FLOG_VA((_L8("CMTPUsbEpBase state on entry = 0x%08X"), iState));

    switch (DataStreamDirection())

        {

    case EReceivingState:

        __FLOG_VA((_L8("Receive data completion status = %d"), iStatus.Int()));

        if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetStreamState(EReceiveComplete);

            }

        else

            {

            // Reissue the request if we got a null packet because the upper layers are not 

        	// interested in null packets.

        	if ((iReceiveData.Length() == 0) && (iReceiveData.MaxLength() > 0))

        		{

        		Connection().Ldd().ReadUntilShort(iStatus, EndpointNumber(), iReceiveData);

        		SetActive();

        		return;

        		}  

            // Update the chunk data length.

            iReceiveChunkData.SetLength(iReceiveChunkData.Length() + iReceiveData.Length());

            if (iIsFirstChunk)

	            {

	            // process the first chunk.

	            ProcessFirstReceivedChunkL();  

	            }

	        else

		        {

		        ResumeReceiveDataStreamL(); 

		        }

            }

        if (iState == EReceiveComplete)

            {

            // Reset the receive data stream and notify the connection.

            MMTPType& data(*iReceiveDataSink);

            ResetReceiveDataStream();

            ReceiveDataCompleteL(iStatus.Int(), data);

            }

        break;

    case ESendingState:   

        __FLOG_VA((_L8("Send data stream completion status = %d"), iStatus.Int())); 

        if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetStreamState(ESendComplete);

            }

        else

            {

            ProcessSendDataStreamL(); 

            }

        if (iState == ESendComplete)

            {

            // Reset the send data stream and notify the connection.

            const MMTPType& data(*iSendDataSource);

            ResetSendDataStream();

            SendDataCompleteL(iStatus.Int(), data);

            }

        break;

    default:

        __FLOG_VA((_L8("Invalid data stream state, status = %d"), iStatus.Int())); 

        Panic(EMTPUsbBadState);

        break;

        }

    __FLOG_VA((_L8("IsActive = %d"), IsActive()));

    __FLOG(_L8("CMTPUsbEpBase::RunL - Exit"));

    }

/**

Provides the current data stream direction.

@return The current data stream direction (EIdle, EReceivingState, or 

ESendingState).

@see TState.

*/

TInt32 CMTPUsbEpBase::DataStreamDirection() const

    {

    return (iState & EStateDirection);

    }

/**

Resets the receive data stream by clearing all receive buffer pointers and

setting the stream state to EIdle.

*/    

void CMTPUsbEpBase::ResetReceiveDataStream()

    {

	__FLOG(_L8("CMTPUsbEpBase::ResetReceiveDataStream - Entry"));

    iReceiveChunkData.Set(NULL, 0, 0);

    iReceiveData.Set(NULL, 0, 0);

    iReceiveDataSink = NULL;

    SetStreamState(EIdle);

	__FLOG(_L8("CMTPUsbEpBase::ResetReceiveDataStream - Exit"));

    }

/**

Resets the receive data stream by clearing all receive buffer pointers and

setting the stream state to EIdle.

*/    

void CMTPUsbEpBase::ResetSendDataStream()

    {

	__FLOG(_L8("CMTPUsbEpBase::ResetSendDataStream - Entry"));

    iSendChunkData.Set(NULL, 0);

    iSendData.Set(NULL, 0);

    iSendDataSource = NULL;

    SetStreamState(EIdle);

	__FLOG(_L8("CMTPUsbEpBase::ResetSendDataStream - Exit"));

    }

/**

This method verify if the received first chunk data is a valid

USB header for BulkOut EP.

@pre this method should only be called after the USB header is received.

@return ETrue if the received first chunk data is a vaild USB header, otherwise EFalse.

*/

TBool CMTPUsbEpBase::ValidateUSBHeaderL()

	{	

	__FLOG(_L8("CMTPUsbEpBase::ValidateUSBHeader - Entry"));

	TBool result(EFalse);

	TUint16 containerType(Connection().BulkContainer().Uint16L(CMTPUsbContainer::EContainerType));

	iDataLength = Connection().BulkContainer().Uint32L(CMTPUsbContainer::EContainerLength);