// 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\src\descriptors.cpp

// Platform independent USB client controller layer (PIL):

// USB descriptor handling and management.

// 

//

#include "usbcdesc.h"

#include "dtestusblogdev.h"

// --- TUsbcDescriptorBase

TUsbcDescriptorBase::TUsbcDescriptorBase()

	:

#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST

	iIndex(0),

#endif

	iBufPtr(NULL, 0)

  	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcDescriptorBase::TUsbcDescriptorBase()")));

	}

TUsbcDescriptorBase::~TUsbcDescriptorBase()

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcDescriptorBase::~TUsbcDescriptorBase()")));

	}

void TUsbcDescriptorBase::SetByte(TUint aPosition, TUint8 aValue)

	{

	iBufPtr[aPosition] = aValue;

	}

void TUsbcDescriptorBase::SetWord(TUint aPosition, TUint16 aValue)

	{

	*reinterpret_cast<TUint16*>(&iBufPtr[aPosition]) = SWAP_BYTES_16(aValue);

	}

TUint8 TUsbcDescriptorBase::Byte(TUint aPosition) const

	{

	return iBufPtr[aPosition];

	}

TUint16 TUsbcDescriptorBase::Word(TUint aPosition) const

	{

	return SWAP_BYTES_16(*reinterpret_cast<const TUint16*>(&iBufPtr[aPosition]));

	}

void TUsbcDescriptorBase::GetDescriptorData(TDes8& aBuffer) const

	{

	aBuffer = iBufPtr;

	}

TInt TUsbcDescriptorBase::GetDescriptorData(TUint8* aBuffer) const

	{

	__MEMCPY(aBuffer, iBufPtr.Ptr(), Size());

	return Size();

	}

TInt TUsbcDescriptorBase::GetDescriptorData(TUint8* aBuffer, TInt aMaxSize) const

	{

	if (aMaxSize < Size())

		{

		// No use to copy only half a descriptor

		return 0;

		}

	return GetDescriptorData(aBuffer);

	}

const TDes8& TUsbcDescriptorBase::DescriptorData() const

	{

	return iBufPtr;

	}

TDes8& TUsbcDescriptorBase::DescriptorData()

	{

	return iBufPtr;

	}

TInt TUsbcDescriptorBase::Size() const

	{

	return iBufPtr.Size();

	}

TUint8 TUsbcDescriptorBase::Type() const

	{

	return iBufPtr[1];

	}

void TUsbcDescriptorBase::SetBufferPointer(const TDesC8& aDes)

	{

	iBufPtr.Set(const_cast<TUint8*>(aDes.Ptr()), aDes.Size(), aDes.Size());

	}

// --- TUsbcDeviceDescriptor

TUsbcDeviceDescriptor::TUsbcDeviceDescriptor()

	: iBuf()

  	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcDeviceDescriptor::TUsbcDeviceDescriptor()")));

	}

TUsbcDeviceDescriptor* TUsbcDeviceDescriptor::New(TUint8 aDeviceClass, TUint8 aDeviceSubClass,

												  TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

												  TUint16 aVendorId, TUint16 aProductId,

												  TUint16 aDeviceRelease, TUint8 aNumConfigurations)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcDeviceDescriptor::New()")));

	TUsbcDeviceDescriptor* self = new TUsbcDeviceDescriptor();

	if (self)

		{

		if (self->Construct(aDeviceClass, aDeviceSubClass, aDeviceProtocol, aMaxPacketSize0, aVendorId,

							aProductId, aDeviceRelease, aNumConfigurations) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcDeviceDescriptor::Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass, TUint8 aDeviceProtocol,

									  TUint8 aMaxPacketSize0, TUint16 aVendorId, TUint16 aProductId,

									  TUint16 aDeviceRelease, TUint8 aNumConfigurations)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcDeviceDescriptor::Construct()")));

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = (TUint8)iBuf.Size();									// bLength

	iBuf[1] = KUsbDescType_Device;							// bDescriptorType

 	SetWord(2, KUsbcUsbVersion);							// bcdUSB

	iBuf[4] = aDeviceClass;									// bDeviceClass

	iBuf[5] = aDeviceSubClass;								// bDeviceSubClass

	iBuf[6] = aDeviceProtocol;								// bDeviceProtocol

	iBuf[7] = aMaxPacketSize0;								// bMaxPacketSize0

	SetWord(8, aVendorId);									// idVendor

	SetWord(10, aProductId);								// idProduct

	SetWord(12, aDeviceRelease);							// bcdDevice

	iBuf[14] = 0;											// iManufacturer

	iBuf[15] = 0;											// iProduct

	iBuf[16] = 0;											// iSerialNumber

	iBuf[17] = aNumConfigurations;							// bNumConfigurations

	return KErrNone;

	}

// --- TUsbcConfigDescriptor

TUsbcConfigDescriptor::TUsbcConfigDescriptor()

	: iBuf()

  	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcConfigDescriptor::TUsbcConfigDescriptor()")));

	}

TUsbcConfigDescriptor* TUsbcConfigDescriptor::New(TUint8 aConfigurationValue, TBool aSelfPowered,

												  TBool aRemoteWakeup, TUint8 aMaxPower)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcConfigDescriptor::New()")));

	TUsbcConfigDescriptor* self = new TUsbcConfigDescriptor();

	if (self)

		{

		if (self->Construct(aConfigurationValue, aSelfPowered, aRemoteWakeup, aMaxPower) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcConfigDescriptor::Construct(TUint8 aConfigurationValue, TBool aSelfPowered,

									   TBool aRemoteWakeup, TUint8 aMaxPower)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcConfigDescriptor::Construct()")));

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = (TUint8)iBuf.Size();									// bLength

	iBuf[1] = KUsbDescType_Config;							// bDescriptorType

	SetWord(2, KUsbDescSize_Config);						// wTotalLength

	iBuf[4] = 0;											// bNumInterfaces

	iBuf[5] = aConfigurationValue;							// bConfigurationValue

	iBuf[6] = 0;											// iConfiguration

	iBuf[7] = (TUint8)(0x80 | (aSelfPowered ? 0x40 : 0) | (aRemoteWakeup ? 0x20 : 0)); // bmAttributes (bit 7 always 1)

	iBuf[8] = (TUint8)(aMaxPower / 2);								// MaxPower (2mA units!)

	return KErrNone;

	}

// --- TUsbcInterfaceDescriptor

TUsbcInterfaceDescriptor::TUsbcInterfaceDescriptor()

	: iBuf()

  	{

 	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcInterfaceDescriptor::TUsbcInterfaceDescriptor()")));

	}

TUsbcInterfaceDescriptor* TUsbcInterfaceDescriptor::New(TUint8 aInterfaceNumber, TUint8 aAlternateSetting,

														TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcInterfaceDescriptor::New()")));

	TUsbcInterfaceDescriptor* self = new TUsbcInterfaceDescriptor();

	if (self)

		{

		if (self->Construct(aInterfaceNumber, aAlternateSetting, aNumEndpoints, aClassInfo) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcInterfaceDescriptor::Construct(TUint8 aInterfaceNumber, TUint8 aAlternateSetting,

										 TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcInterfaceDescriptor::Construct()")));

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = (TUint8)iBuf.Size();									// bLength

	iBuf[1] = KUsbDescType_Interface;						// bDescriptorType

	iBuf[2] = aInterfaceNumber;								// bInterfaceNumber

	iBuf[3] = aAlternateSetting;							// bAlternateSetting

	iBuf[4] = (TUint8)aNumEndpoints;								// bNumEndpoints

	iBuf[5] = (TUint8)aClassInfo.iClassNum;							// bInterfaceClass

	iBuf[6] = (TUint8)aClassInfo.iSubClassNum;						// bInterfaceSubClass

	iBuf[7] = (TUint8)aClassInfo.iProtocolNum;						// bInterfaceProtocol

	iBuf[8] = 0;											// iInterface

	return KErrNone;

	}

// --- TUsbcEndpointDescriptor

TUsbcEndpointDescriptor::TUsbcEndpointDescriptor()

	: iBuf()

  	{

 	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcEndpointDescriptor::TUsbcEndpointDescriptor()")));

	}

TUsbcEndpointDescriptor* TUsbcEndpointDescriptor::New(TUint8 aEndpointAddress,

													  const TUsbcEndpointInfo& aEpInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcEndpointDescriptor::New()")));

	TUsbcEndpointDescriptor* self = new TUsbcEndpointDescriptor();

	if (self)

		{

		if (self->Construct(aEndpointAddress, aEpInfo) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcEndpointDescriptor::Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcEndpointDescriptor::Construct()")));

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = (TUint8)iBuf.Size();									// bLength

	iBuf[1] = KUsbDescType_Endpoint;						// bDescriptorType

 	iBuf[2] = aEndpointAddress;								// bEndpointAddress

	iBuf[3] = (TUint8)EpTypeMask2Value(aEpInfo.iType);				// bmAttributes

	SetWord(4, (TUint8)aEpInfo.iSize);								// wMaxPacketSize

	iBuf[6] = (TUint8)aEpInfo.iInterval;							// bInterval

	return KErrNone;

	}

// --- TUsbcAudioEndpointDescriptor

TUsbcAudioEndpointDescriptor::TUsbcAudioEndpointDescriptor()

	: iBuf()

  	{

 	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcAudioEndpointDescriptor::TUsbcAudioEndpointDescriptor()")));

	}

TUsbcAudioEndpointDescriptor* TUsbcAudioEndpointDescriptor::New(TUint8 aEndpointAddress,

																const TUsbcEndpointInfo& aEpInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcAudioEndpointDescriptor::New()")));

	TUsbcAudioEndpointDescriptor* self = new TUsbcAudioEndpointDescriptor();

	if (self)

		{

		if (self->Construct(aEndpointAddress, aEpInfo) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcAudioEndpointDescriptor::Construct(TUint8 aEndpointAddress, const TUsbcEndpointInfo& aEpInfo)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcAudioEndpointDescriptor::Construct()")));

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = (TUint8)iBuf.Size();									// bLength

	iBuf[1] = KUsbDescType_Endpoint;						// bDescriptorType

 	iBuf[2] = aEndpointAddress;								// bEndpointAddress

	iBuf[3] = (TUint8)EpTypeMask2Value(aEpInfo.iType);				// bmAttributes

	SetWord(4, (TUint8)aEpInfo.iSize);								// wMaxPacketSize

	iBuf[6] = (TUint8)aEpInfo.iInterval;							// bInterval

	iBuf[7] = 0;

	iBuf[8] = 0;

	return KErrNone;

	}

// --- TUsbcClassSpecificDescriptor

TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()

	: iBuf(NULL)

  	{

 	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcClassSpecificDescriptor::TUsbcClassSpecificDescriptor()")));

	}

TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcClassSpecificDescriptor::~TUsbcClassSpecificDescriptor()")));

	delete iBuf;

	}

TUsbcClassSpecificDescriptor* TUsbcClassSpecificDescriptor::New(TUint8 aType, TInt aSize)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcClassSpecificDescriptor::New()")));

	TUsbcClassSpecificDescriptor* self = new TUsbcClassSpecificDescriptor();

	if (self)

		{

		if (self->Construct(aType, aSize) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcClassSpecificDescriptor::Construct(TUint8 aType, TInt aSize)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcClassSpecificDescriptor::Construct()")));

	__NEWPLATBUF(iBuf, aSize);

	if (!iBuf)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf(__KSTRING("  Error: Allocation of CS desc buffer failed")));

		return KErrNoMemory;

		}

	SetBufferPointer(*iBuf);

	SetByte(1, aType);										// bDescriptorType

	return KErrNone;

	}

// --- TUsbcStringDescriptorBase

TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()

	: /*iIndex(0),*/ iSBuf(0), iBufPtr(NULL, 0)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptorBase::TUsbcStringDescriptorBase()")));

	}

TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptorBase::~TUsbcStringDescriptorBase()")));

	}

TUint16 TUsbcStringDescriptorBase::Word(TUint aPosition) const

	{

	if (aPosition <= 1)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf(__KSTRING("TUsbcStringDescriptorBase::Word: Error: Word(%d) in string descriptor!"), aPosition));

		return 0;

		}

	else

		{

		// since iBufPtr[0] is actually string descriptor byte index 2,

		// we have to subtract 2 from the absolute position.

		return SWAP_BYTES_16(*reinterpret_cast<const TUint16*>(&iBufPtr[aPosition - 2]));

		}

	}

TInt TUsbcStringDescriptorBase::GetDescriptorData(TUint8* aBuffer) const

	{

	aBuffer[0] = iSBuf[0];

	aBuffer[1] = iSBuf[1];

	__MEMCPY(&aBuffer[2], iBufPtr.Ptr(), iBufPtr.Size());

	return Size();

	}

TInt TUsbcStringDescriptorBase::GetDescriptorData(TUint8* aBuffer, TInt aMaxSize) const

	{

	if (aMaxSize < Size())

		{

		// No use to copy only half a string

		return 0;

		}

	return GetDescriptorData(aBuffer);

	}

const TDes8& TUsbcStringDescriptorBase::StringData() const

	{

	return iBufPtr;

	}

TDes8& TUsbcStringDescriptorBase::StringData()

	{

	return iBufPtr;

	}

TInt TUsbcStringDescriptorBase::Size() const

	{

	return iSBuf[0];

	}

void TUsbcStringDescriptorBase::SetBufferPointer(const TDesC8& aDes)

	{

	iBufPtr.Set(const_cast<TUint8*>(aDes.Ptr()), aDes.Size(), aDes.Size());

	}

// --- TUsbcStringDescriptor

TUsbcStringDescriptor::TUsbcStringDescriptor()

	: iBuf(NULL)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptor::TUsbcStringDescriptor()")));

	}

TUsbcStringDescriptor::~TUsbcStringDescriptor()

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptor::~TUsbcStringDescriptor()")));

	delete iBuf;

	}

TUsbcStringDescriptor* TUsbcStringDescriptor::New(const TDesC8& aString)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptor::New")));

	TUsbcStringDescriptor* self = new TUsbcStringDescriptor();

	if (self)

		{

		if (self->Construct(aString) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcStringDescriptor::Construct(const TDesC8& aString)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcStringDescriptor::Construct")));

	__NEWPLATBUF(iBuf, aString.Size());

	if (!iBuf)

		{

		__KTRACE_OPT(KPANIC, Kern::Printf(__KSTRING("  Error: Allocation of string buffer failed")));

		return KErrNoMemory;

		}

	SetBufferPointer(*iBuf);

	iBufPtr.Copy(aString);

	iSBuf.SetMax();

	iSBuf[0] = (TUint8)(iBuf->Size() + 2); // Bytes

	iSBuf[1] = KUsbDescType_String;

	return KErrNone;

	}

// --- TUsbcLangIdDescriptor

TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()

	: iBuf(NULL)

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcLangIdDescriptor::TUsbcLangIdDescriptor()")));

	}

TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()

	{

	__KTRACE_OPT(KUSB, Kern::Printf(__KSTRING("TUsbcLangIdDescriptor::~TUsbcLangIdDescriptor()")));