// 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

*/

#ifndef CMTPUSBCONNECTION_H

#define CMTPUSBCONNECTION_H

#include <e32base.h>

#include <d32usbc.h>

#include <mtp/mtpdataproviderapitypes.h>

#include <mtp/tmtptyperequest.h>

#include <mtp/tmtptypeevent.h>

#include <mtp/tmtptypenull.h>

#include "mtpusbtransportconstants.h"

#include "mmtptransportconnection.h"

#include "mtpdebug.h"

#include "tmtpusbcontrolrequestsetup.h"

#include "tmtpusbcontrolrequestcanceldata.h"

#include "tmtpusbcontrolrequestdevicestatus.h"

#include "tmtpusbcontrolrequestmodfunction.h"

#include "tmtpusbcontrolrequestmodheader.h"

#include "tmtpusbparameterpayloadblock.h"

class CMTPUsbContainer;

class CMTPUsbEpBase;

class MMTPConnectionProtocol;

class MMTPConnectionMgr;

class MMTPType;

/** 

Implements the MTP USB device class connection protocol and transport layer 

interface.

@internalComponent

*/

class CMTPUsbConnection : 

    public CActive, 

    public MMTPTransportConnection 

    {

public:

    static CMTPUsbConnection* NewL(MMTPConnectionMgr& aConnectionMgr);

    ~CMTPUsbConnection();

public: // From MMTPTransportConnection

    void BindL(MMTPConnectionProtocol& aProtocol);

    MMTPConnectionProtocol& BoundProtocolLayer();

    void CloseConnection();

    void ReceiveDataL(MMTPType& aData, const TMTPTypeRequest& aRequest);

    void ReceiveDataCancelL(const TMTPTypeRequest& aRequest);   

    void SendDataL(const MMTPType& aData, const TMTPTypeRequest& aRequest);

    void SendDataCancelL(const TMTPTypeRequest& aRequest);    

    void SendEventL(const TMTPTypeEvent& aEvent);  

    void SendResponseL(const TMTPTypeResponse& aResponse, const TMTPTypeRequest& aRequest);  

    void TransactionCompleteL(const TMTPTypeRequest& aRequest); 

    void Unbind(MMTPConnectionProtocol& aProtocol);

    TAny* GetExtendedInterface(TUid aInterfaceUid); 

    TUint GetImplementationUid();

public:

    void ReceiveBulkDataCompleteL(TInt aError, MMTPType& aData);

    void ReceiveControlRequestDataCompleteL(TInt aError, MMTPType& aData);

    void ReceiveControlRequestSetupCompleteL(TInt aError, MMTPType& aData);

    void SendBulkDataCompleteL(TInt aError, const MMTPType& aData);

    void SendControlRequestDataCompleteL(TInt aError, const MMTPType& aData);

    void SendInterruptDataCompleteL(TInt aError, const MMTPType& aData);

    TUint EndpointBitPosition(TUint aId) const;

    const TUsbcEndpointCaps& EndpointCapsL(TUint aId);

    TUint EndpointDirection(TUint aId) const;

    TUint EndpointDirectionAndType(TUint aId) const;

    TEndpointNumber EndpointNumber(TUint aId) const;

    TUint EndpointType(TUint aId) const;

    RDevUsbcClient& Ldd();

    CMTPUsbContainer& BulkContainer();

    TMTPTypeRequest& GetCurrentRequest()

        {

        return iMTPRequest;

        }

private: // From CActive

    void DoCancel();

    TInt RunError(TInt aError);

    void RunL();

private:

    CMTPUsbConnection(MMTPConnectionMgr& aConnectionMgr);

    void ConstructL();

    void IssueAlternateDeviceStatusNotifyRequest();

    void BufferEventDataL(const TMTPTypeEvent& aEvent);

    void SendEventDataL();

    void SendUnreportedStatusEventL();

    void InitiateBulkRequestSequenceL();

    void InitiateControlRequestSequenceL();

    void ProcessBulkCommandL(TInt aError);

    void ProcessBulkDataInL(const TMTPTypeRequest& aRequest, const MMTPType& aData);

    void ProcessBulkDataOutL(TInt aError);

    void ProcessControlRequestCancelL(const TMTPUsbControlRequestSetup& aRequest);

    void ProcessControlRequestDeviceResetL(const TMTPUsbControlRequestSetup& aRequest);

    void ProcessControlRequestDeviceStatusL(const TMTPUsbControlRequestSetup& aRequest);

    TBool BulkRequestErrorHandled(TInt aError);

    TBool BulkRequestTransactionStateValid(TMTPTransactionPhase aExpectedTransactionState);

    TBool ControlRequestErrorHandled(TInt aError);

    void ConfigurationDescriptorSetL();

    void ConfigurationDescriptorClear();

    TBool ConnectionClosed() const;

    TBool ConnectionOpen() const;

    void ControlEndpointStartL();

    void ControlEndpointStop();

    void BulkEndpointsStallL();

    void BulkEndpointsStallClearL();

    void DataEndpointsStartL();

    void DataEndpointsStop();

    void EndpointStallL(TMTPUsbEndpointId aId);

    void EndpointStallClearL(TMTPUsbEndpointId aId);

    void ResumeConnectionL();

    void StartConnectionL();

    void StopConnection();

    void SuspendConnectionL();

    void StartUsbL();

    void StopUsb();

    TInt32 ConnectionState() const;

    TInt32 SuspendState() const;

    void SetBulkTransactionState(TMTPTransactionPhase aState);

    void SetConnectionState(TInt32 aState);

    void SetDeviceStatus(TUint16 aCode);

    void SetInterfaceDescriptorL();

    void SetSuspendState(TInt32 aState);

    void SetTransportPacketSizeL();

    TBool IsEpStalled(const TUint& aEpNumber);

private: // Owned.

    /**

    The MTP USB device class connection state bit flags.

    */

    enum TConnectionState

        {

        /**

        The Connection is closed.

        */

        EIdle                   = 0x00000000,

        /**

        The Connection is open and in an error state pending a device reset control

        request from the host.

        */

        EStalled                = 0x00000001,

        /**

        The Connection is open and inactive.

        */

        EOpen                   = 0x00000002,

        /**

        The Connection is open and actively processing a bulk data transfer.

        */

        EBusy                   = 0x00000004,

        /**

        The connection state bit flags mask.

        */

        EConnectionStateMask    = 0x0000000F,

        };

    /**

    The MTP USB suspend state bit flags.

    */

    enum TSuspendState

        {

        /**

        The USB device is not suspended.

        */

        ENotSuspended           = 0x00000000,

        /**

        The USB device is suspended.

        */

        ESuspended              = 0x80000000,

        /**

        The USB device is suspended and asynchronous MTP event data is awaiting

        transmission to the host.

        */

        ESuspendedEventsPending = 0xC0000000,

        /**

        The suspend state bit flags mask.

        */

        ESuspendStateMask       = 0xF0000000,

        };

    /**

    Defines the MTP USB device class endpoint meta data.

    */

    struct TEpInfo

        {        

        /**

        The logical endpoint bit position.

        */

        TUint           iBitPosition;   

        /**

        The endpoint direction flag bits.

        */

        TUint           iDirection; 

        /**

        The endpoint polling interval.

        */

        TUint           iInterval;

        /**

        The high speed NAK rate

        */

        TUint			iInterval_Hs;    

        /**

        The logical endpoint number.

        */

        TEndpointNumber iNumber; 

        /**

        The endpoint type flag bits.

        */

        TUint           iType;         

        };

    /**

    The bulk transfer transaction state.

    */

    TMTPTransactionPhase                                iBulkTransactionState;

    /** 

    The current USB controller/interface alternate setting state.

    */

    TUint                                               iControllerStateCurrent;

    /** 

    The previous USB controller/interface alternate setting state.

    */

    TUint                                               iControllerStatePrevious;

    /**

    The USB device capabilities buffer.

    */

    TUsbDeviceCaps                                      iDeviceCaps;

    /**

    The current device status.

    */

    TUint16                                             iDeviceStatusCode;

    /**

    The endpoint capabilities buffer.

    */

    TUsbcEndpointCaps                                   iEndpointCaps;

    /**

    The USB device endpoints capability sets.

    */

    TUsbcEndpointData                                   iEndpointCapSets[KUsbcMaxEndpoints];

    /** 

    The USB MTP device class endpoints.

    */

    RPointerArray<CMTPUsbEpBase>                        iEndpoints;

    /** 

    The USB device.

    */

    RDevUsbcClient                                      iLdd;

    /**

    The MTP event dataset buffer.

    */

    TMTPTypeEvent                                       iMTPEvent;

    /**

    Event pending flag.

    */

    TBool												iEventPending;

    /**

    The active MTP operation request dataset buffer.

    */

    TMTPTypeRequest                                     iMTPRequest;

    /** 

    The active MTP SessionID.

    */

    TUint32                                             iMTPSessionId;

    /**

    The remote wakeup enabled flag.

    */

    TBool                                               iRemoteWakeup;

    /**

    The MTP USB device class state variable.

    */

    TInt32                                              iState;

    /** 

    The USB MTP device class generic bulk pipe container buffer.

    */

    CMTPUsbContainer*                                   iUsbBulkContainer;

    /**

    The USB MTP device class variable length Command/Response Block payload 

    dataset. 

    */

    TMTPUsbParameterPayloadBlock                        iUsbBulkParameterBlock;

    /** 

    The USB MTP device class event dataset buffer.

    */

    CMTPUsbContainer*                                   iUsbEventContainer;

    /**

    The USB MTP device class variable length Event Block payload dataset. 

    */

    TMTPUsbParameterPayloadBlock                        iUsbEventParameterBlock;

    /** 

    MTP USB device class cancel control request dataset buffer.

    */

    TMTPUsbControlRequestCancelData                     iUsbControlRequestCancelData;

    /** 

    MTP USB device class device status control request dataset buffer.

    */

    TMTPUsbControlRequestDeviceStatus                   iUsbControlRequestDeviceStatus;

    /** 

    The MTP USB device class control request setup dataset buffer.

    */

    TMTPUsbControlRequestSetup                          iUsbControlRequestSetup;

    /** 

    The MTP USB device class Microsoft OS Feature Descriptor (MOD) header 

    section dataset buffer.

    */

    TMTPUsbControlRequestMODHeader                      iUsbMODHeader;

    /** 

    The MTP USB device class Microsoft OS Feature Descriptor (MOD) function 

    section dataset buffer.

    */

    TMTPUsbControlRequestMODFunction                    iUsbMODFunction;

    /**

    The MTP USB device class endpoint meta data table.

    */

    static const TEpInfo                                KEndpointMetaData[];

    const TFixedArray<TEpInfo, EMTPUsbEpNumEndpoints>   iEndpointInfo;

	/**

	Cached error code in case of a ItoR transaction error.

	*/

	TInt												iXferError;

	/**

	Data sink for consuming data during error recovery from

	a failed ItoR transaction.

	*/

	TMTPTypeNull										iNull;

	/**

	Buffer for reading discarded data into.

	*/

	RBuf8												iNullBuffer;

	/**

	A flag to reflect if a Host initiated cancel transaction

	is triggered.

	*/

	TBool 												iIsCancelReceived;

    /**

    FLOGGER debug trace member variable.

    */

    __FLOG_DECLARATION_MEMBER_MUTABLE;

private: // Not owned.

    /** 

    The MTP connection manager.

    */

    MMTPConnectionMgr*                                  iConnectionMgr;

    /** 

    The MTP connection protocol layer binding.

    */

    MMTPConnectionProtocol*                             iProtocolLayer;

    /**

     * indicate if a transaction_cannled needs to be return to PC

     */

    TBool                                               isResponseTransactionCancelledNeeded;

	/**

	 * indicate if a transaction has been ignored

	 */

	TBool												isCommandIgnored;

    };

#endif // CMTPUSBCONNECTION_H