// Copyright (c) 2004-2009 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:

// f32test\testusbcldd\inc\dtestusblogdev.h

// Test USB logical channel classes.

// 

//

/**

 @file

 @internalTechnology

*/

#ifndef __DTESTUSBCLOGDEVICE_H_

#define __DTESTUSBCLOGDEVICE_H_

#include "kerndefs.h"

#include "usbcdesc.h"

const TInt KTestUsbcMajorVersion = 0;

const TInt KTestUsbcMinorVersion = 1;

const TInt KTestUsbcBuildVersion = 1;

const TInt KTestUsbcMaxRequests = 10;

/** The USB version we are compliant with (BCD) */

const TUint16 KUsbcUsbVersion = 0x0110;

/** The Ep0 tx buffer area */

const TInt KUsbcBufSz_Ep0Tx = 1024;

/** Size of buffer for transferring data from client and host */

const TInt KTransferBufSize = 1024;

/** Must correspond to the max enum of TRequest + 1;

	currently this is ERequestEndpointStatusNotify = 9 */

const TInt KUsbcMaxRequests = 10;

/** Maximum number of endpoints an Interface may have */

const TInt KUsbcMaxEpNumber = 5;

/** Size of endpoint buffers */

const TInt KEndpointBufferSize = 16 * 1024;

class DTestUsbcEndpoint;

class DTestUsbcLogDevice : public DLogicalDevice

	{

public:

	DTestUsbcLogDevice();

	~DTestUsbcLogDevice();

	TInt Install();

	void GetCaps(TDes8& aDes) const;

	TInt Create(DLogicalChannelBase*& aChannel);

	DLogicalChannel* CreateL();

private:

	RPointerArray<DTestUsbcEndpoint> iEndpoints;

	};

class TUsbcInterfaceSet;

class TUsbcLogicalEndpoint;

/** This is one 'Alternate Setting' of an interface. */

class TUsbcInterface

	{

public:

	TUsbcInterface(TUsbcInterfaceSet* aIfcSet, TUint8 aSetting);

	~TUsbcInterface();

public:

	/** Array of endpoints making up (belonging to) this setting. */

	RPointerArray<TUsbcLogicalEndpoint> iEndpoints;

	/** 'Back' pointer. */

	TUsbcInterfaceSet* const iInterfaceSet;

	/** bAlternateSetting (zero-based). */

	const TUint8 iSettingCode;

	};

/** This is an 'Interface' (owning 1 or more alternate settings TUsbcInterface). */

class TUsbcInterfaceSet

	{

public:

	TUsbcInterfaceSet(const DBase* aClientId, TUint8 aIfcNum);

	~TUsbcInterfaceSet();

	const TUsbcInterface* CurrentInterface() const;

	TUsbcInterface* CurrentInterface();

public:

	/** Array of alternate settings provided by (belonging to) this interface. */

	RPointerArray<TUsbcInterface> iInterfaces;

	/** Pointer to the LDD which created and owns this interface. */

	const DBase* const iClientId;

	/** bInterfaceNumber (zero-based). */

	TUint8 iInterfaceNumber;

	/** bAlternateSetting (zero-based). */

	TUint8 iCurrentInterface;

	};

/** This is a logical 'Endpoint', as used by our device configuration model. */

class TUsbcLogicalEndpoint

	{

public:

	TUsbcLogicalEndpoint(TUint aEndpointNum, const TUsbcEndpointInfo& aInfo,

						 TUsbcInterface* aInterface);

	~TUsbcLogicalEndpoint();

	public:

	/** The virtual (logical) endpoint number. */

	const TInt iLEndpointNum;

	/** This endpoint's info structure. */

	TUsbcEndpointInfo iInfo;

	/** 'Back' pointer. */

	const TUsbcInterface* iInterface;

	};

class DLddTestUsbcChannel : public DLogicalChannel

	{

public:

	DLddTestUsbcChannel(RPointerArray<DTestUsbcEndpoint>& aEndpoints);	

	void HandleMsg(TMessageBase* aMsg);

	TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	~DLddTestUsbcChannel();

private:

	TInt DoCancel(TInt aReqNo);

	void DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2);

	TInt DoControl(TInt aFunction, TAny* a1, TAny* a2);

	TBool ValidateEndpoint(TUsbcEndpointInfo* aEndpointInfo);

	TInt SetInterface(TInt aInterfaceNumber, TUsbcInterfaceInfoBuf *aUserInterfaceInfoBuf, TPtr8* aInterfaceString);

	TInt SetInterface(TInt aInterfaceNumber, TUsbcClassInfo& aClass, TDesC8* aString,

					  TInt aTotalEndpointsUsed, const TUsbcEndpointInfo aEndpointData[]);

	TUsbcInterface* CreateInterface(TInt aIfc);

	void DeleteInterface(TInt aIfc);

	void DeleteInterfaceSet();

	TInt CreateEndpoints(TUsbcInterface* aIfc, TInt aEndpointsUsed, const TUsbcEndpointInfo aEndpointData[]);

	TInt SetupIfcDescriptor(TUsbcInterface* aIfc, TUsbcClassInfo& aClass,

							TDesC8* aString, const TUsbcEndpointInfo aEndpointData[]);

	TInt ReleaseInterface(TInt aInterfaceNumber);

	TInt HostEndpointStatusNotify(TInt aEndpointNumber, TRequestStatus* aStatus);

	TInt EndpointStatusNotify(TUint* aEndpointMask, TRequestStatus* aStatus);

	void EndpointStatusNotifyCallback();

	TInt ClearEndpoint(TInt aEndpointNumber);

	TInt DoTransferAsyncReq(TInt aEndpointNumber, TAny* a1, TAny* a2, TRequestStatus& aStatus);

	TBool ValidEndpoint(TInt aEndpointNumber);

	TInt FindRealEndpoint(TInt aEndpointNumber);

	TInt HaltClearEndpoint(TBool aHalt, TInt aEndpointNumber);

	void AlternateDeviceStatusNotify();

	TInt SetAlternateDeviceStatusNotify(TRequestStatus* aStatus, TUint* aValue);

	void CancelAlternateDeviceStatusNotify();

	TInt ReEnumerate(TRequestStatus* aStatus);

	void SetDeviceState(TUsbcDeviceState aState);

private:

	DThread* iClient;

	TUsbcDescriptorPool iDescriptors;

	TUsbcInterfaceSet iIfcSet;

	RPointerArray<DTestUsbcEndpoint>& iEndpoints;

	TUint* iEndpointStatusMask;

	TRequestStatus* iEndpointStatusNotifyRequest;

	TRequestStatus* iAlternateDeviceStatusNotifyRequest;

	TUint* iAlternateDeviceStatusNotifyValue;

	TUsbcDeviceState iDeviceState;

public:

	static const TUsbcEndpointData iEndpointData[];

	friend class DTestUsbcEndpoint;

	};

class DTestUsbcEndpoint : public DBase

	{

public:

	DTestUsbcEndpoint();

	~DTestUsbcEndpoint();

	TInt Create(const TUsbcEndpointCaps& aCaps);

	TInt TryToComplete();

	TInt CopyData(TInt aSrcOffset, DThread* aDestClient, TDesC8* aDest,

				  TInt aDestOffset, TInt aLen);

	TBool SupportsDir(TUint aDir);

	TBool EndpointSuitable(const TUsbcEndpointInfo& aInfo);

	void DoCancel();

	TInt Halt();

	TInt Clear();

	TBool IsHalted();

	void SetClearCallback(DLddTestUsbcChannel* aCallback);

	TInt HostStatusNotify(DThread* aHost, TRequestStatus* aStatus);

	TInt NewRequest(DThread* aClient, TRequestStatus* aStatus, TEndpointTransferInfo& aInfo, TTransferType aType);

	TInt NewHostRequest(DThread* aHost, TRequestStatus* aStatus, TEndpointTransferInfo& aInfo, TTransferType aType);

private:

	TRequestStatus* iClientStatus;

	TRequestStatus* iHostStatus;

	TRequestStatus* iHostNotifyStatus;

	DThread* iClient;

	DThread* iHost;

	DThread* iNotifyHost;

	TUsbcEndpointCaps iCaps;

	TBool iRequestPending;

	TBool iHostRequestPending;

	TEndpointTransferInfo iClientTransferInfo;

	TEndpointTransferInfo iHostTransferInfo;

	TInt iDataTransferred;

	TInt iHostDataTransferred;

	TTransferType iRequestType;

	TTransferType iHostRequestType;

	HBuf8Plat* iBuffer;

	TBool iHalted;

	DLddTestUsbcChannel* iClearCallback;

public:

	TBool iReserve;

	};

#endif // __DTESTUSBCLOGDEVICE_H_