// Copyright (c) 2002-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:
// e32/include/drivers/usbcdesc.h
// USB descriptors and their management.
// 
//

/**
 @file usbcdesc.h
 @internalTechnology
*/

#ifndef __USBCDESC_H__
#define __USBCDESC_H__

#include <kernel/kernel.h>


// Hard-wired positions of some descriptors in iDescriptors array (whether present or not):
static const TInt KDescPosition_Device           = 0;
static const TInt KDescPosition_DeviceQualifier  = 1;
static const TInt KDescPosition_OtherSpeedConfig = 2;
static const TInt KDescPosition_Config           = 3;
static const TInt KDescPosition_Otg              = 4;
static const TInt KDescPosition_FirstAvailable   = 5;

// Hard-wired positions of string descriptors in iStrings array (whether present or not):
static const TInt KStringPosition_Langid           = 0;
static const TInt KStringPosition_Manufact         = 1;
static const TInt KStringPosition_Product          = 2;
static const TInt KStringPosition_Serial           = 3;
static const TInt KStringPosition_Config           = 4;
static const TInt KStringPosition_OtherSpeedConfig = 5;
static const TInt KStringPosition_FirstAvailable   = 6;


class TUsbcDescriptorBase
	{
public:
	virtual ~TUsbcDescriptorBase();
	void SetByte(TInt aPosition, TUint8 aValue);
	void SetWord(TInt aPosition, TUint16 aValue);
	TUint8 Byte(TInt aPosition) const;
	TUint16 Word(TInt aPosition) const;
	void GetDescriptorData(TDes8& aBuffer) const;
	TInt GetDescriptorData(TUint8* aBuffer) const;
	TInt GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const;
	const TDes8& DescriptorData() const;
	TDes8& DescriptorData();
	TUint Size() const;
	TUint8 Type() const;
	virtual void UpdateFs();
	virtual void UpdateHs();
protected:
	TUsbcDescriptorBase();
	void SetBufferPointer(const TDesC8& aDes);
private:
#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST
	TUint8 iIndex;											// only needed for SET_DESCRIPTOR
#endif
	TPtr8 iBufPtr;
	};


class TUsbcDeviceDescriptor : public TUsbcDescriptorBase
	{
public:
	/** aMaxPacketSize0 should be the Ep0 max packet size for FS operation (as the HS size
		is fixed and known).
	*/
	static TUsbcDeviceDescriptor* New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,
									  TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,
									  TUint16 aVendorId, TUint16 aProductId,
									  TUint16 aDeviceRelease, TUint8 aNumConfigurations);
	virtual void UpdateFs();
	virtual void UpdateHs();
private:
	TUsbcDeviceDescriptor();
	TInt Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,
				   TUint8 aMaxPacketSize0, TUint16 aVendorId, TUint16 aProductId,
				   TUint16 aDeviceRelease, TUint8 aNumConfigurations);
	TBuf8<KUsbDescSize_Device> iBuf;
	TUint8 iEp0Size_Fs;										// holds Ep0 size for FS (could be < 64)
	};


class TUsbcDeviceQualifierDescriptor : public TUsbcDescriptorBase
	{
public:
	/** aMaxPacketSize0 should be the Ep0 max packet size for FS operation (as the HS size
		is fixed and known).
	*/
	static TUsbcDeviceQualifierDescriptor* New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,
											   TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,
											   TUint8 aNumConfigurations, TUint8 aReserved=0);
	virtual void UpdateFs();
	virtual void UpdateHs();
private:
	TUsbcDeviceQualifierDescriptor();
	TInt Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,
				   TUint8 aMaxPacketSize0, TUint8 aNumConfigurations, TUint8 aReserved);
	TBuf8<KUsbDescSize_DeviceQualifier> iBuf;
	TUint8 iEp0Size_Fs;										// holds Ep0 size for FS (could be < 64)
	};


class TUsbcConfigDescriptor : public TUsbcDescriptorBase
	{
public:
	/** aMaxPower should be given here in milliamps (not mA/2). */
	static TUsbcConfigDescriptor* New(TUint8 aConfigurationValue, TBool aSelfPowered, TBool aRemoteWakeup,
									  TUint16 aMaxPower);
private:
	TUsbcConfigDescriptor();
	TInt Construct(TUint8 aConfigurationValue, TBool aSelfPowered, TBool aRemoteWakeup, TUint16 aMaxPower);
	TBuf8<KUsbDescSize_Config> iBuf;
	};


// The Other_Speed_Configuration descriptor has same size and layout as the
// standard Configuration descriptor, therefore we don't need a new definition.
typedef TUsbcConfigDescriptor TUsbcOtherSpeedConfigDescriptor;


class TUsbcInterfaceDescriptor : public TUsbcDescriptorBase
	{
public:
	static TUsbcInterfaceDescriptor* New(TUint8 aInterfaceNumber, TUint8 aAlternateSetting, TInt NumEndpoints,
										 const TUsbcClassInfo& aClassInfo);
private:
	TUsbcInterfaceDescriptor();
	TInt Construct(TUint8 aInterfaceNumber, TUint8 aAlternateSetting, TInt aNumEndpoints,
				   const TUsbcClassInfo& aClassInfo);
	TBuf8<KUsbDescSize_Interface> iBuf;
	};


class TUsbcEndpointDescriptorBase : public TUsbcDescriptorBase
	{
public:
	virtual void UpdateFs();
	virtual void UpdateHs();
protected:
	TInt Construct(const TUsbcEndpointInfo& aEpInfo);
	TUsbcEndpointDescriptorBase();
protected:
	/** Stores the endpoint size to be used for FS. */
	TInt iEpSize_Fs;
	/** Stores the endpoint size to be used for HS. */
	TInt iEpSize_Hs;
	/** Stores the endpoint polling interval to be used for FS. */
	TInt iInterval_Fs;
	/** Stores the endpoint polling interval to be used for HS. */
	TInt iInterval_Hs;
	};


class TUsbcEndpointDescriptor : public TUsbcEndpointDescriptorBase
	{
public:
	static TUsbcEndpointDescriptor* New(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
private:
	TUsbcEndpointDescriptor();
	TInt Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
	TBuf8<KUsbDescSize_Endpoint> iBuf;
	};


class TUsbcAudioEndpointDescriptor : public TUsbcEndpointDescriptorBase
	{
public:
	static TUsbcAudioEndpointDescriptor* New(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
private:
	TUsbcAudioEndpointDescriptor();
	TInt Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo);
	TBuf8<KUsbDescSize_AudioEndpoint> iBuf;
	};


class TUsbcOtgDescriptor : public TUsbcDescriptorBase
	{
public:
	static TUsbcOtgDescriptor* New(TBool aHnpSupport, TBool aSrpSupport);
private:
	TUsbcOtgDescriptor();
	TInt Construct(TBool aHnpSupport, TBool aSrpSupport);
	TBuf8<KUsbDescSize_Otg> iBuf;
	};


class TUsbcClassSpecificDescriptor : public TUsbcDescriptorBase
	{
public:
	virtual ~TUsbcClassSpecificDescriptor();
	static TUsbcClassSpecificDescriptor* New(TUint8 aType, TInt aSize);
private:
	TUsbcClassSpecificDescriptor();
	TInt Construct(TUint8 aType, TInt aSize);
	HBuf8* iBuf;
	};


class TUsbcStringDescriptorBase
	{
public:
	virtual ~TUsbcStringDescriptorBase();
	TUint16 Word(TInt aPosition) const;
	void SetWord(TInt aPosition, TUint16 aValue);
	TInt GetDescriptorData(TUint8* aBuffer) const;
	TInt GetDescriptorData(TUint8* aBuffer, TUint aMaxSize) const;
	const TDes8& StringData() const;
	TDes8& StringData();
	TUint Size() const;
	void SetBufferPointer(const TDesC8& aDes);
protected:
	TUsbcStringDescriptorBase();
	TBuf8<2> iSBuf;
	TPtr8 iBufPtr;
private:
//	TUint8 iIndex;											// not needed in DescriptorPool: position == index
	};


class TUsbcStringDescriptor : public TUsbcStringDescriptorBase
	{
public:
	virtual ~TUsbcStringDescriptor();
	static TUsbcStringDescriptor* New(const TDesC8& aString);
private:
	TUsbcStringDescriptor();
	TInt Construct(const TDesC8& aString);
	HBuf8* iBuf;
	};


// Currently we support only one language, and thus there's no need to provide
// a LangId string descriptor with more than one array element.
class TUsbcLangIdDescriptor : public TUsbcStringDescriptorBase
	{
public:
	virtual ~TUsbcLangIdDescriptor();
	static TUsbcLangIdDescriptor* New(TUint16 aLangId);
private:
	TUsbcLangIdDescriptor();
	TInt Construct(TUint16 aLangId);
	TBuf8<2> iBuf;
	};


class TUsbcDescriptorPool
	{
public:
	TUsbcDescriptorPool(TUint8* aEp0_TxBuf);
	~TUsbcDescriptorPool();
	TInt Init(TUsbcDeviceDescriptor* aDeviceDesc, TUsbcConfigDescriptor* aConfigDesc,
			  TUsbcLangIdDescriptor* aLangId, TUsbcStringDescriptor* aManufacturer,
			  TUsbcStringDescriptor* aProduct, TUsbcStringDescriptor* aSerialNum,
			  TUsbcStringDescriptor* aConfig, TUsbcOtgDescriptor* aOtgDesc);
	TInt InitHs();
	TInt UpdateDescriptorsFs();
	TInt UpdateDescriptorsHs();

	// Descriptors
	TInt FindDescriptor(TUint8 aType, TUint8 aIndex, TUint16 aLangid, TInt& aSize) const;
	void InsertDescriptor(TUsbcDescriptorBase* aDesc);
	void DeleteIfcDescriptor(TInt aNumber, TInt aSetting=0);
	// The TC in many of the following functions stands for 'ThreadCopy' because that's what happens there.
	TInt GetDeviceDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
	TInt SetDeviceDescriptorTC(DThread* aThread, const TDes8& aBuffer);
	TInt GetConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
	TInt SetConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer);
    TInt GetOtgDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
	TInt SetOtgDescriptor(const TDesC8& aBuffer);
	TInt GetInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting) const;
	TInt SetInterfaceDescriptor(const TDes8& aBuffer, TInt aInterface, TInt aSetting);
	TInt GetEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting,
								 TUint8 aEndpointAddress) const;
	TInt SetEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
								 TUint8 aEndpointAddress);
	TInt GetEndpointDescriptorSize(TInt aInterface, TInt aSetting, TUint8 aEndpointAddress, TInt& aSize) const;
	TInt GetDeviceQualifierDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
	TInt SetDeviceQualifierDescriptorTC(DThread* aThread, const TDes8& aBuffer);
	TInt GetOtherSpeedConfigurationDescriptorTC(DThread* aThread, TDes8& aBuffer) const;
	TInt SetOtherSpeedConfigurationDescriptorTC(DThread* aThread, const TDes8& aBuffer);
	TInt GetCSInterfaceDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting) const;
	TInt SetCSInterfaceDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
									TInt aSize);
	TInt GetCSInterfaceDescriptorSize(TInt aInterface, TInt aSetting, TInt& aSize) const;
	TInt GetCSEndpointDescriptorTC(DThread* aThread, TDes8& aBuffer, TInt aInterface, TInt aSetting,
								   TUint8 aEndpointAddress) const;
	TInt SetCSEndpointDescriptorTC(DThread* aThread, const TDes8& aBuffer, TInt aInterface, TInt aSetting,
								   TUint8 aEndpointAddress, TInt aSize);
	TInt GetCSEndpointDescriptorSize(TInt aInterface, TInt aSetting, TUint8 aEndpointAddress, TInt& aSize) const;

	// String descriptors
	void SetIfcStringDescriptor(TUsbcStringDescriptor* aDesc, TInt aNumber, TInt aSetting=0);
	TInt GetStringDescriptorLangIdTC(DThread* aThread, TDes8& aLangId) const;
	TInt SetStringDescriptorLangId(TUint16 aLangId);
	TInt GetManufacturerStringDescriptorTC(DThread* aThread, TDes8& aString) const;
	TInt SetManufacturerStringDescriptorTC(DThread* aThread, const TDes8& aString);
	TInt RemoveManufacturerStringDescriptor();
	TInt GetProductStringDescriptorTC(DThread* aThread, TDes8& aString) const;
	TInt SetProductStringDescriptorTC(DThread* aThread, const TDes8& aString);
	TInt RemoveProductStringDescriptor();
	TInt GetSerialNumberStringDescriptorTC(DThread* aThread, TDes8& aString) const;
	TInt SetSerialNumberStringDescriptorTC(DThread* aThread, const TDes8& aString);
	TInt RemoveSerialNumberStringDescriptor();
	TInt GetConfigurationStringDescriptorTC(DThread* aThread, TDes8& aString) const;
	TInt SetConfigurationStringDescriptorTC(DThread* aThread, const TDes8& aString);
	TInt RemoveConfigurationStringDescriptor();
	TInt GetStringDescriptorTC(DThread* aThread, TInt aIndex, TDes8& aString) const;
	TInt SetStringDescriptorTC(DThread* aThread, TInt aIndex, const TDes8& aString);
	TInt RemoveStringDescriptor(TInt aIndex);

private:
	// Descriptors
	void InsertIfcDesc(TUsbcDescriptorBase* aDesc);
	void InsertEpDesc(TUsbcDescriptorBase* aDesc);
	TInt FindIfcDescriptor(TInt aIfcNumber, TInt aIfcSetting) const;
	TInt FindEpDescriptor(TInt aIfcNumber, TInt aIfcSetting, TUint8 aEpAddress) const;
	void DeleteDescriptors(TInt aIndex, TInt aCount = 1);
	void UpdateConfigDescriptorLength(TInt aLength);
	void UpdateConfigDescriptorNumIfcs(TInt aNumber);
	void UpdateIfcNumbers(TInt aNumber);
	TInt GetDeviceDescriptor(TInt aIndex) const;
	TInt GetConfigurationDescriptor(TInt aIndex) const;
	TInt GetOtgDescriptor() const;

	// String descriptors
	TInt GetStringDescriptor(TInt aIndex) const;
	TInt GetDeviceStringDescriptorTC(DThread* aThread, TDes8& aString, TInt aIndex, TInt aPosition) const;
	TInt SetDeviceStringDescriptorTC(DThread* aThread, const TDes8& aString, TInt aIndex, TInt aPosition);
	TInt RemoveDeviceStringDescriptor(TInt aIndex, TInt aPosition);
	void ExchangeStringDescriptor(TInt aIndex, const TUsbcStringDescriptor* aDesc);
	TBool AnyStringDescriptors() const;
	TBool StringDescriptorExists(TInt aIndex) const;
	TInt FindAvailableStringPos() const;

private:
	// Data members
	RPointerArray<TUsbcDescriptorBase> iDescriptors;
	RPointerArray<TUsbcStringDescriptorBase> iStrings;
	TInt iIfcIdx;
	TUint8* const iEp0_TxBuf;								// points to the controller's ep0 TX buffer
	TBool iHighSpeed;										// true if currently operating at high-speed
	};


#endif	// __USBCDESC_H__