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