// Copyright (c) 1997-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 __USBCONN_H__
#define __USBCONN_H__

#include <e32base.h>
#include <usb.h>
#include <d32usbc.h>
#include <obex/transport/obexreaderbase.h>
#include <obex/transport/obexwriterbase.h>
#include <obex/transport/obexconnector.h>
#include <obex/transport/mobextransportnotify.h>
#include <obexconstants.h>
#include <obexusbtransportinfo.h>
#include "ObexUsbTransportController.h"

//
// LDD name
//
_LIT(KUsbLddName, "eusbc");

// Transmit and receive endpoints
// Note that these are the virtual endpoint numbers for the bulk interface and
// should be put in the same order in the TUsbcEndpointInfo array in RegInterfacesL
const TEndpointNumber KTransmitEndpoint = EEndpoint1;
const TEndpointNumber KReceiveEndpoint  = EEndpoint2;

// These are taken from section 6.5 of the WMCDC spec.
const TUint KObexDescriptorLength = 18;
const TUint KObexMinNumEndpoints = 3;
const TUint KObexClassNumber = 0x02;
const TUint KObexNumInterfaces = 2;
const TUint KObexSubClassNumber = 0x0b;
const TUint KObexProtocolNumber = 0x0;
const TUint KObexTotalEndpoints = 2;

const TUint KObexDataClass = 0x0A;
const TUint KObexDataSubClass = 0;
const TUint KObexAlt0 = 0;
const TUint KObexAlt1 = 1;
const TUint KObexFunctionalDescriptorLength = 5;
const TUint KObexDefaultInterfaceDescriptorLength = 100; //Default value used prior to OS 9.2
const TUint KObexInterfaceDescriptorBlockLength = 16;

const TUint8 KCdcVersionNumber[2] = { 0x10, 0x01 }; // CDC v1.1
const TUint8 KHeaderFunctionalDescriptor = 0x00;
const TUint8 KObexFunctionalDescriptor = 0x15;
const TUint8 KWmcdcVersionNumber[2] = { 0x00, 0x01 }; // WMCDC v1.0
const TUint8 KUnionFunctionalDescriptor = 0x06;

const TInt KMaxPacketTypeBulkFS = 64;
const TInt KMaxPacketTypeBulkHS = 512;


/**
USB Active Writer class
*/
NONSHARABLE_CLASS(CObexUsbActiveWriter) : public CObexWriterBase
//------------------------------------------------------------------------------------
	{
public:
	static CObexUsbActiveWriter* NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo, TInt aPacketSize);
	~CObexUsbActiveWriter();

private:
	virtual void DoCancel();
	virtual void DoTransfer();

private:
	CObexUsbActiveWriter(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo, TInt aPacketSize);

private:
	RDevUsbcClient& iUsb;       // USB logical device driver
	TInt iPacketSize;
	};


/**
USB Active Reader class
*/
NONSHARABLE_CLASS(CObexUsbActiveReader) : public CObexReaderBase
//------------------------------------------------------------------------------------
    {
public:
	static CObexUsbActiveReader* NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo);
	~CObexUsbActiveReader();

private:
	virtual void DoCancel();
	virtual void DoTransfer();
	virtual TInt GetMaxPacketSize();
	virtual TInt GetInitialPacketSize();	
private:
	CObexUsbActiveReader(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb, TObexConnectionInfo& aInfo);
private:
	RDevUsbcClient& iUsb;       // USB logical device driver
	TBool iGotHeader;
    };
    

/**
Used by the USB underlying object to notify changes in the transport link.
*/
NONSHARABLE_CLASS(MObexUsbConnector)
//------------------------------------------------------------------------------------
	{
public:
	/**
	@internalComponent
	Called in response to the USB transport coming up.
	*/
	virtual void TransportUp() =0;
	
	/**
	@internalComponent
	Called in response to the USB transport going down.
	@param aErr An error value associated with the transport down event.
	*/
	virtual void TransportDown(TInt aErr = KErrDisconnected) =0;
	
	/**
	@internalComponent
	Called when an endpoint stall has been cleared.
	*/
	virtual void StallCleared() =0;
	};


/**
Handles the underlying details of a USB connection.  Monitors the state of
the transport and notifies owner as transport goes up and down.
*/
NONSHARABLE_CLASS(CObexUsbHandler) : public CActive
//------------------------------------------------------------------------------------
    {
public:
	virtual ~CObexUsbHandler();

	static CObexUsbHandler* NewL(TObexUsbTransportInfo& aUsbTransportInfo,
		MObexUsbConnector& aOwner, RDevUsbcClient& aUsb);

	void Start();

	// Implements CActive
	void RunL();
	TInt RunError(TInt /*aError*/);

private:
	CObexUsbHandler(TObexUsbTransportInfo& aUsbProtocolInfo, MObexUsbConnector& aOwner, RDevUsbcClient& aUsb);
	void DoCancel();
	void ConstructL();
	void RegInterfacesL();
	void AllocateDma();
	static void CleanupReleaseInterface0(TAny* aInterface);

private:
	TObexUsbTransportInfo& iObexTransportInfo; // Note: Cannot assume this is valid outside of construction phases
	MObexUsbConnector& iOwner;

	RDevUsbcClient& iUsb;           // USB LDD used for Data Class interface
	RDevUsbcClient iUsbComms;		// USB LDD used for Comms Class interface

	TUint iUsbState;		    	// Used by RDevUsbcClient::AlternateDeviceStatusNotify()
	TBool iTransportUp;             // TRUE when device is configured

	// Interface performance configuration parameters
	// (for extended USB Client Driver API)
	TInt iBandwidthPriority;
	TBool iRequestDmaOnOutEndpoint;
	TBool iRequestDmaOnInEndpoint;
    };


/**
Class to stall then monitor an endpoint and notify owner when the halt state has been cleared.
*/
NONSHARABLE_CLASS(CObexUsbStaller) : public CActive
//------------------------------------------------------------------------------------
	{
public:
	static CObexUsbStaller* NewL(RDevUsbcClient& aUsb, MObexUsbConnector& iOwner);
	~CObexUsbStaller();
	
	void Start();
	
private:
	CObexUsbStaller(RDevUsbcClient& aUsb, MObexUsbConnector& iOwner);
	
	virtual void DoCancel();
	virtual TInt RunError(TInt /*aError*/);
	virtual void RunL();
		
private:
	RDevUsbcClient& iUsb;
	MObexUsbConnector& iOwner;
	TUint iEndpointStatus;
	};


/**
Class to support connecting to other USB devices.
Server mode is relatively straightforward as this corresponds
exactly to how USB works from the device perspective.  Obex client
support though requires some 'magic'.
*/
NONSHARABLE_CLASS(CObexUsbConnector) : public CObexConnector, public MObexUsbConnector
//------------------------------------------------------------------------------------
	{
public:
	/**
	This enum holds the three different states which the connector
	can be in.  In DefaultClient mode, the connector is behaving as
	a client but can be switched to server behaviour.  Once the mode
	has been moved out of DefaultClient (to either Client or Server),
	the mode is locked for the lifetime of the object.  Other
	connectors can provide different behaviour for other CObexServer
	or CObexClient objects.
	*/
	enum TObexUsbMode
		{
		EDefaultClient,
		EClient,
		EServer
		};
	static CObexUsbConnector* NewL(MObexTransportNotify& aOwner, TObexUsbTransportInfo& aUsbTransportInfo);	
	CObexUsbConnector (MObexTransportNotify& aOwner, TObexUsbTransportInfo& aUsbTransportInfo);

	~CObexUsbConnector();

	virtual void ConstructL();

	//Implement MObexUsbConnector interface
	virtual void TransportUp();
	virtual void TransportDown(TInt aErr = KErrDisconnected);
	virtual void StallCleared();	

	//Overrides for pure virtuals in CObexConnector
	virtual void ConnectL();
	virtual void CancelConnect();
	virtual void AcceptL();
	virtual void CancelAccept();
	virtual TBool BringTransportDown();
	virtual void SignalTransportError();
	
	//required to pass the RDevUsbcClient to the activer reader and writer
	RDevUsbcClient* TransportObject();
	TInt GetTransportPacketSize();

private:
	void OpenUsbL(TInt aUnit);	
	static TInt LinkUp(TAny* aConn);
	static TInt NoDevice(TAny* aConn);
	void SignalUp();
	void SignalDown(TInt aErr);
	
	void ResetTransportPacketSize();
	void SetTransportPacketSize();

// Data
private:
	RDevUsbcClient iUsb;	// USB logical device driver
							// Note: This is the handle used for reads and writes.
	TObexUsbTransportInfo& iObexTransportInfo;	// Reference to protocol info to pass on to CObexUsbHandler
												// Note: Cannot assume this is valid outside of construction phases
	TObexUsbMode iMode;
	
	CAsyncCallBack* iCallback;
	TBool iTransportLinkAvailable;
	TBool iConnectRequested;
	TBool iWaitingForLink;
	CObexUsbHandler* iHandler;
	CObexUsbStaller* iStaller;
	
	TInt iPacketSize;
	};


#endif /* __USBCONN_H__ */