// 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 <mtp/mtpprotocolconstants.h>

#include <mtp/tmtptyperesponse.h>

#include "cmtpusbepbulkin.h"

#include "cmtpusbepbulkout.h"

#include "cmtpusbconnection.h"

#include "cmtpusbcontainer.h"

#include "cmtpusbepcontrol.h"

#include "cmtpusbepinterruptin.h"

#include "mmtpconnectionmgr.h"

#include "mmtpconnectionprotocol.h"

#include "mtpbuildoptions.hrh"

#include "mtpdebug.h"

#include "mtpusbpanic.h"

#include "mtpusbprotocolconstants.h"

#ifdef _DEBUG

#include <e32debug.h>

#endif

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

// File type constants.

const TInt KMTPNullChunkSize(0x00020000); // 100KB

const TUint KUSBHeaderSize = 12;

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"UsbConnection");)

// Endpoint meta data.

const CMTPUsbConnection::TEpInfo CMTPUsbConnection::KEndpointMetaData[EMTPUsbEpNumEndpoints] = 

    {

        {KMTPUsbControlEpBit,   KMTPUsbControlEpDir,    KMTPUsbControlEpPoll,   KMTPUsbControlEpNAKRate,	KMTPUsbControlEp,   KMTPUsbControlEpType},  // EMTPUsbEpControl

        {KMTPUsbBulkInEpBit,    KMTPUsbBulkInEpDir,     KMTPUsbBulkInEpPoll,    KMTPUsbBulkInEpNAKRate,		KMTPUsbBulkInEp,    KMTPUsbBulkInEpType},   // EMTPUsbEpBulkIn

        {KMTPUsbBulkOutEpBit,   KMTPUsbBulkOutEpDir,    KMTPUsbBulkOutEpPoll,   KMTPUsbBulkOutEpNAKRate,	KMTPUsbBulkOutEp,   KMTPUsbBulkOutEpType},  // EMTPUsbEpBulkOut

        {KMTPUsbInterruptEpBit, KMTPUsbInterruptEpDir,  KMTPUsbInterruptEpPoll, KMTPUsbInterruptEpNAKRate,	KMTPUsbInterruptEp, KMTPUsbInterruptEpType} // EMTPUsbEpInterrupt

    }; 

/**

USB MTP USB device class connection factory method.

@param aConnectionMgr The MTP connection manager interface.

@return A pointer to an MTP USB device class connection. Ownership IS 

transfered.

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

*/

CMTPUsbConnection* CMTPUsbConnection::NewL(MMTPConnectionMgr& aConnectionMgr)

    {

    CMTPUsbConnection* self = new (ELeave) CMTPUsbConnection(aConnectionMgr);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

Destructor.

*/

CMTPUsbConnection::~CMTPUsbConnection()

    {

    __FLOG(_L8("~CMTPUsbConnection - Entry"));

    // Terminate all endpoint data transfer activity.

    StopConnection();

    // Close the device class endpoints and generic container buffers.

    iEndpoints.ResetAndDestroy();

    delete iUsbBulkContainer;

    delete iUsbEventContainer;

    // Stop the USB device.

    StopUsb();

    iNullBuffer.Close();

    if (iProtocolLayer != NULL)

        {

        BoundProtocolLayer().Unbind(*this);

        }

    iProtocolLayer = NULL;

    __FLOG(_L8("~CMTPUsbConnection - Exit"));

    __FLOG_CLOSE;

    }

void CMTPUsbConnection::BindL(MMTPConnectionProtocol& aProtocol)

    {

    __FLOG(_L8("BindL - Entry"));

    __ASSERT_DEBUG(!iProtocolLayer, Panic(EMTPUsbBadState));

    iProtocolLayer = &aProtocol;

    __FLOG(_L8("BindL - Exit"));

    }

MMTPConnectionProtocol& CMTPUsbConnection::BoundProtocolLayer()

    {

    __FLOG(_L8("BoundProtocolLayer - Entry"));

    __ASSERT_DEBUG(iProtocolLayer, Panic(EMTPUsbBadState));

    __FLOG(_L8("BoundProtocolLayer - Exit"));

    return *iProtocolLayer;

    }

void CMTPUsbConnection::CloseConnection()

    {

    __FLOG(_L8("CloseConnection - Entry"));

    /* 

    Terminate all endpoint data transfer activity, stall all but the control 

    endpoints, and wait for the host to issue a Device Reset Request.

    */

    StopConnection();

    TRAPD(err, BulkEndpointsStallL());

    UNUSED_VAR(err);

    __FLOG(_L8("CloseConnection - Exit"));

    }

void CMTPUsbConnection::ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& /*aRequest*/)

    {

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

    // Update the transaction state.

    SetBulkTransactionState(EDataIToRPhase);

    // Setup the bulk container and initiate the bulk data receive sequence.

    iUsbBulkContainer->SetPayloadL(&aData);

    //Expected containerType pre-setup here in case we don't receive IToR dataphase at all so 

    //Cancel operation can trigger right call inside ReceiveBulkDataCompleteL(). 

    iUsbBulkContainer->SetUint16L(CMTPUsbContainer::EContainerType, EMTPUsbContainerTypeDataBlock);

    static_cast<CMTPUsbEpBulkOut*>(iEndpoints[EMTPUsbEpBulkOut])->ReceiveBulkDataL(*iUsbBulkContainer);

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

    }

void CMTPUsbConnection::ReceiveDataCancelL(const TMTPTypeRequest& /*aRequest*/)

    {

    __FLOG(_L8("ReceiveDataCancelL - Entry"));

    // Store the device status code.

    TUint16 deviceStatus = iDeviceStatusCode;

    SetDeviceStatus(EMTPUsbDeviceStatusTransactionCancelled);

   	static_cast<CMTPUsbEpBulkOut*>(iEndpoints[EMTPUsbEpBulkOut])->CancelReceiveL(KErrCancel);

   	// Restore it.

   	SetDeviceStatus(deviceStatus);

    __FLOG(_L8("ReceiveDataCancelL - Exit"));

    }

void CMTPUsbConnection::SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest)

    {

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

    ProcessBulkDataInL(aRequest, aData);

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

    }

void CMTPUsbConnection::SendDataCancelL(const TMTPTypeRequest& /*aRequest*/)

    {

    __FLOG(_L8("SendDataCancelL - Entry"));

    // Store the device status code.

    TUint16 deviceStatus = iDeviceStatusCode;

    SetDeviceStatus(EMTPUsbDeviceStatusTransactionCancelled);

 	static_cast<CMTPUsbEpBulkIn*>(iEndpoints[EMTPUsbEpBulkIn])->CancelSendL(KErrCancel);

 	// Restore it.

   	SetDeviceStatus(deviceStatus);

    __FLOG(_L8("SendDataCancelL - Exit"));

    }

void CMTPUsbConnection::SendEventL(const TMTPTypeEvent& aEvent)

    {    

    __FLOG(_L8("SendEventL - Entry"));

    // Reset the event.

    iMTPEvent.Reset(); 

    MMTPType::CopyL(aEvent, iMTPEvent);

    switch (ConnectionState())

        {

    case EIdle:

    case EStalled:

        // Drop the event.    

        __FLOG(_L8("Dropping the event")); 

        BoundProtocolLayer().SendEventCompleteL(KErrNone, aEvent);

        break;

    case EOpen:

    case EBusy:

        // Process the event.    

        switch (SuspendState())

            {

        case ENotSuspended:

            // Only send event if there are no pending events

            if (!iEventPending)

            	{

            	// Send the event data.

	            __FLOG(_L8("Sending the event"));

    	        BufferEventDataL(aEvent);

        	    SendEventDataL(); 	

            	}

             break;

        case ESuspended:

            /* 

            If remote wakeup is enabled then signal remote wakeup and buffer 

            the event. The event will be sent when bus signalling is resumed. 

            Otherwise the event is dropped, and a PTP UnreportedStatus event 

            issued when the host resumes the connection.

            */

            if (iLdd.SignalRemoteWakeup() == KErrNone)

                {

                // Remote wakeup is enabled, buffer the event data.

                __FLOG(_L8("Buffer event data and signal remote wakeup"));

                BufferEventDataL(aEvent);

                }

            else

                {

                // Remote wakeup is not enabled, drop the event.    

                __FLOG(_L8("Dropping the event")); 

                BoundProtocolLayer().SendEventCompleteL(KErrNone, aEvent);

                }

            /*

            Update state to trigger the correct processing when the USB connection is resumed.

            */

            SetSuspendState(ESuspendedEventsPending);

            break;

        case ESuspendedEventsPending:

            // Drop the event.    

            __FLOG(_L8("Dropping the event")); 

            BoundProtocolLayer().SendEventCompleteL(KErrNone, aEvent);

            break; 

        default:

            __FLOG(_L8("Invalid suspend state"));

            Panic(EMTPUsbBadState);

            break;

            }

        break;

    default:

        __FLOG(_L8("Invalid connection state"));

        Panic(EMTPUsbBadState);

        break;

        }

    __FLOG(_L8("SendEventL - Exit"));

    }

void CMTPUsbConnection::SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest)

    {

    __FLOG(_L8("SendResponseL - Entry"));

    __FLOG_VA((_L8("DeviceState: 0x%x TransactionState: 0x%x Connection: 0x%x"), iDeviceStatusCode, iBulkTransactionState, ConnectionState()));

    // Update the transaction state.

	SetBulkTransactionState(EResponsePhase);

    if (SuspendState() != ESuspended && !iIsCancelReceived)

    	{  	      

   		TUint16 opCode(aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode));

   		TUint16 rspCode(aResponse.Uint16(TMTPTypeResponse::EResponseCode));

   		__FLOG_VA((_L8("ResponseCode = 0x%04X, Operation Code = 0x%04X"), rspCode, opCode));

   		if ((opCode == EMTPOpCodeOpenSession) && (rspCode == EMTPRespCodeOK))

        	{        

   	    	// An session has been opened. Record the active SessionID.

       		iMTPSessionId = aRequest.Uint32(TMTPTypeRequest::ERequestParameter1);

       		__FLOG_VA((_L8("Processing OpenSession response, SessionID = %d"), iMTPSessionId));

       		}

   		else if (((opCode == EMTPOpCodeCloseSession) || (opCode == EMTPOpCodeResetDevice))&& (rspCode == EMTPRespCodeOK))

        	{

   	    	// An session has been closed. Clear the active SessionID.        

       		__FLOG_VA((_L8("Processing CloseSession or ResetDevice response, SessionID = %d"), iMTPSessionId));

       		iMTPSessionId = KMTPSessionNone;

       		}

   		/* 

   		Setup the parameter block payload dataset. Note that since this is a 

   		variable length dataset, it must first be reset.

   		*/

   		iUsbBulkParameterBlock.Reset();

        TBool isNullParamValid = EFalse;

   		// Setup the bulk container.

   		iUsbBulkContainer->SetPayloadL(const_cast<TMTPUsbParameterPayloadBlock*>(&iUsbBulkParameterBlock));

   		iUsbBulkContainer->SetUint32L(CMTPUsbContainer::EContainerLength, static_cast<TUint32>(iUsbBulkContainer->Size()));

   		iUsbBulkContainer->SetUint16L(CMTPUsbContainer::EContainerType, EMTPUsbContainerTypeResponseBlock);

   		iUsbBulkContainer->SetUint16L(CMTPUsbContainer::ECode, rspCode);

   		iUsbBulkContainer->SetUint32L(CMTPUsbContainer::ETransactionID, aRequest.Uint32(TMTPTypeRequest::ERequestTransactionID));

    	// Initiate the bulk data send sequence.

   		__FLOG_VA((_L8("Sending response 0x%04X (%d bytes)"), iUsbBulkContainer->Uint16L(CMTPUsbContainer::ECode), iUsbBulkContainer->Uint32L(CMTPUsbContainer::EContainerLength)));

   		static_cast<CMTPUsbEpBulkIn*>(iEndpoints[EMTPUsbEpBulkIn])->SendBulkDataL(*iUsbBulkContainer);

    	}

    else

    	{

    	BoundProtocolLayer().SendResponseCompleteL(KErrNone, aResponse, aRequest);

    	}

    __FLOG(_L8("SendResponseL - Exit"));

    } 

void CMTPUsbConnection::TransactionCompleteL(const TMTPTypeRequest& /*aRequest*/)

    {

    __FLOG(_L8("TransactionCompleteL - Entry"));

   	__FLOG_VA((_L8("DeviceState: 0x%x TransactionState: 0x%x"), iDeviceStatusCode, iBulkTransactionState));

   	if (iBulkTransactionState != ERequestPhase)

   	    {

        // Update the transaction state.

        SetBulkTransactionState(EIdlePhase);    

        // Update the device status

        SetDeviceStatus(EMTPUsbDeviceStatusOK);     

        // Clear the cancel flag.

        iIsCancelReceived = EFalse; 

        if (ConnectionOpen())

            {

            // Initiate the next request phase bulk data receive sequence.

            InitiateBulkRequestSequenceL();   		    

            }

        else if (iIsResetRequestSignaled)

            {

            iIsResetRequestSignaled = EFalse;

            StartConnectionL();

            }

   	    }

    __FLOG(_L8("TransactionCompleteL - Exit"));

    } 

void CMTPUsbConnection::Unbind(MMTPConnectionProtocol& /*aProtocol*/)

    {

    __FLOG(_L8("Unbind - Entry"));

    __ASSERT_DEBUG(iProtocolLayer, Panic(EMTPUsbBadState));

    iProtocolLayer = NULL;

    __FLOG(_L8("Unbind - Exit"));

    } 

TAny* CMTPUsbConnection::GetExtendedInterface(TUid /*aInterfaceUid*/)

    {

    return NULL;    

    }

TUint CMTPUsbConnection::GetImplementationUid()

    {

    return KMTPUsbTransportImplementationUid;

    }

void CMTPUsbConnection::ReceiveBulkDataCompleteL(TInt aError, MMTPType& /*aData*/)

    {

    __FLOG(_L8("ReceiveBulkDataCompleteL - Entry"));  

    if (!BulkRequestErrorHandled(aError))

        { 

        TUint type(iUsbBulkContainer->Uint16L(CMTPUsbContainer::EContainerType));        

	    __FLOG_VA((_L8("Received container type 0x%04X"), type));

	    // The proper behaviour at this point is to stall the end points

	    // but alas Microsoft does not honor this.

	    // The solution is to store the error code, consume all the data

	    // sent and then forward the error code to the upper layers

	    // which will then go through all the phases

	    // Only go here if...

       	if (aError != KErrNone // there is an error

       		&& type == EMTPUsbContainerTypeDataBlock // it is a data transfer

       		&& iDeviceStatusCode != EMTPUsbDeviceStatusTransactionCancelled // we haven't been cancelled by the initiator

            )

       		{

       		__FLOG_VA((_L8("ReceiveBulkDataCompleteL - error: %d"), aError));

       		iXferError = aError;

       		// Update the transaction state.

    		SetBulkTransactionState(EDataIToRPhase);

		    // Setup the bulk container and initiate the bulk data receive sequence.

		    iNullBuffer.Close();

		    iNullBuffer.CreateL(KMTPNullChunkSize);

		    iNullBuffer.SetLength(KMTPNullChunkSize);

		    iNull.SetBuffer(iNullBuffer);

    		iUsbBulkContainer->SetPayloadL(&iNull);

    		static_cast<CMTPUsbEpBulkOut*>(iEndpoints[EMTPUsbEpBulkOut])->ResumeReceiveDataL(*iUsbBulkContainer);

       		}            

	    else

	    	{

	    	if (iXferError != KErrNone)

	    		{

	    		aError = iXferError;

	    		iXferError = KErrNone;

	    		iNullBuffer.Close();

	    		}

   	        switch (type)

	            {

    	    case EMTPUsbContainerTypeCommandBlock:

        	    ProcessBulkCommandL(aError);

           		break;

        	case EMTPUsbContainerTypeDataBlock:

            	ProcessBulkDataOutL(aError);

            	break;

        	case EMTPUsbContainerTypeResponseBlock:

        	case EMTPUsbContainerTypeEventBlock:

        	default:

            	// Invalid container received, shutdown the bulk data pipe.

            	__FLOG_VA((_L8("Invalid container type = 0x%04X"), type));

            	CloseConnection();

            	}

	        // Reset the bulk container.

			/* A special case for handling MTP framework's synchronous error handling during the request phase. 

				( ie at the beginning of this function, we are in the request phase, the request is sent to the 

				mtp f/w, which may send a synchronous error response, which will be populated into the usb bulk 

				container and sent out by the bulk In AO. When this function is completing, the response phase 

				has already been reached, and the container is in use by the bulk In AO, so the payload is not 

				reset)*/

    	    if((iBulkTransactionState != EResponsePhase)&&(!isCommandIgnored))

	        	{

				iUsbBulkContainer->SetPayloadL(NULL);

				}    	    

			// clear the flag

			isCommandIgnored = false;

	    	}         

        }

    __FLOG(_L8("ReceiveBulkDataCompleteL - Exit"));

    }

void CMTPUsbConnection::ReceiveControlRequestDataCompleteL(TInt aError, MMTPType& /*aData*/)

    {

    __FLOG(_L8("ReceiveControlRequestDataCompleteL - Entry"));

    if (!ControlRequestErrorHandled(aError))

        {

        // Complete the control request sequence.

        static_cast<CMTPUsbEpControl*>(iEndpoints[EMTPUsbEpControl])->SendControlRequestStatus();

        if (iUsbControlRequestSetup.Uint8(TMTPUsbControlRequestSetup::EbRequest) == EMTPUsbControlRequestCancel)

            {

            // Cancel data received.

            __FLOG(_L8("Cancel request data received."));

            // Setup the event dataset.

            __FLOG_VA((_L8("Cancellation Code = 0x%04X"), iUsbControlRequestCancelData.Uint16(TMTPUsbControlRequestCancelData::ECancellationCode)));

            __FLOG_VA((_L8("Transaction ID = 0x%08X"), iUsbControlRequestCancelData.Uint32(TMTPUsbControlRequestCancelData::ETransactionID)));

			#ifdef _DEBUG            

            // print log about the cacel event

            RDebug::Print(_L("cancel event received!!!!!!!!!!!!!!!!!Transaction phase is %d ----------------\n"), BoundProtocolLayer().TransactionPhaseL(iMTPSessionId));

            RDebug::Print(_L("The Transaction ID want to canceled is %d -------------"), iUsbControlRequestCancelData.Uint32(TMTPUsbControlRequestCancelData::ETransactionID));

            RDebug::Print(_L("Current Transaction ID is %d ----------------"),iMTPRequest.Uint32(TMTPTypeRequest::ERequestTransactionID));

			#endif

            isResponseTransactionCancelledNeeded = true;

            if(  BoundProtocolLayer().TransactionPhaseL(iMTPSessionId) > EIdlePhase   ) 

            	{

	            iMTPEvent.Reset();

	            iMTPEvent.SetUint16(TMTPTypeEvent::EEventCode, iUsbControlRequestCancelData.Uint16(TMTPUsbControlRequestCancelData::ECancellationCode));

	            iMTPEvent.SetUint32(TMTPTypeEvent::EEventSessionID, iMTPSessionId);

	            // replace the transaction id in the event with the current transaction id

	            iMTPEvent.SetUint32(TMTPTypeEvent::EEventTransactionID, iMTPRequest.Uint32(TMTPTypeRequest::ERequestTransactionID));

	            // Set the cancel flag.

	            iIsCancelReceived = ETrue;

	            // Update the device status.

	       		SetDeviceStatus(EMTPUsbDeviceStatusBusy);   

	            // Notify the protocol layer.

	            if (ConnectionOpen())

	                {

	                BoundProtocolLayer().ReceivedEventL(iMTPEvent);

	                }

            	}

            else

            	{

				#ifdef _DEBUG 

            	RDebug::Print(_L("cancel evnet received at idle state, stop data EPs, flush rx data, restart data eps,statusOK\n"));

				#endif

            	// stop data endpoint

            	DataEndpointsStop();

            	//flush rx data

            	TInt  nbytes = 0;

            	TInt err = iLdd.QueryReceiveBuffer(EndpointNumber(EMTPUsbEpBulkOut), nbytes);

				#ifdef _DEBUG

            	RDebug::Print(_L("QueryReceiveBuffer()-----err is %d , nbytes is %d"), err, nbytes);

				#endif	  

            	// has data, read it

            	if( (err == KErrNone) && (nbytes > 0) )

            		{

            		// create the read buff

            		RBuf8 readBuf;

            		readBuf.CreateL(nbytes);

            		// synchronously read the data

            		TRequestStatus status;

            		iLdd.ReadOneOrMore(status, EndpointNumber(EMTPUsbEpBulkOut), readBuf);

            		User::WaitForRequest(status);