// 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/drivers/usbcc/descriptors.cpp

// Platform independent layer (PIL) of the USB Device controller driver:

// USB descriptor handling and management.

// 

//

/**

 @file descriptors.cpp

 @internalTechnology

*/

#include <kernel/kern_priv.h>

#include <drivers/usbc.h>

// Debug Support

static const char KUsbPanicCat[] = "USB PIL";

// --- TUsbcDescriptorBase

TUsbcDescriptorBase::TUsbcDescriptorBase()

	:

#ifdef USB_SUPPORTS_SET_DESCRIPTOR_REQUEST

	iIndex(0),

#endif

	iBufPtr(NULL, 0)

	{

	}

TUsbcDescriptorBase::~TUsbcDescriptorBase()

	{

	}

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

	{

	iBufPtr[aPosition] = aValue;

	}

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

	{

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

	}

TUint8 TUsbcDescriptorBase::Byte(TInt aPosition) const

	{

	return iBufPtr[aPosition];

	}

TUint16 TUsbcDescriptorBase::Word(TInt 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, TUint 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;

	}

TUint TUsbcDescriptorBase::Size() const

	{

	return iBufPtr.Size();

	}

TUint8 TUsbcDescriptorBase::Type() const

	{

	return iBufPtr[1];

	}

void TUsbcDescriptorBase::UpdateFs()

	{

	// virtual function can be overridden in derived classes.

	return;

	}

void TUsbcDescriptorBase::UpdateHs()

	{

	// virtual function can be overridden in derived classes.

	return;

	}

void TUsbcDescriptorBase::SetBufferPointer(const TDesC8& aDes)

	{

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

	}

// --- TUsbcDeviceDescriptor

TUsbcDeviceDescriptor::TUsbcDeviceDescriptor()

	: iBuf()

	{

	}

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

												  TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

												  TUint16 aVendorId, TUint16 aProductId,

												  TUint16 aDeviceRelease, TUint8 aNumConfigurations)

	{

	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)

	{

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = 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

	iEp0Size_Fs = aMaxPacketSize0;

	return KErrNone;

	}

void TUsbcDeviceDescriptor::UpdateFs()

	{

	SetByte(7, iEp0Size_Fs);								// bMaxPacketSize0

	}

void TUsbcDeviceDescriptor::UpdateHs()

	{

	SetByte(7, 64);											// bMaxPacketSize0

	}

// --- TUsbcDeviceQualifierDescriptor

TUsbcDeviceQualifierDescriptor::TUsbcDeviceQualifierDescriptor()

	: iBuf()

	{

	}

TUsbcDeviceQualifierDescriptor* TUsbcDeviceQualifierDescriptor::New(TUint8 aDeviceClass,

																	TUint8 aDeviceSubClass,

																	TUint8 aDeviceProtocol,

																	TUint8 aMaxPacketSize0,

																	TUint8 aNumConfigurations,

																	TUint8 aReserved)

	{

	TUsbcDeviceQualifierDescriptor* self = new TUsbcDeviceQualifierDescriptor();

	if (self)

		{

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

							aNumConfigurations, aReserved) != KErrNone)

			{

			delete self;

			return NULL;

			}

		}

	return self;

	}

TInt TUsbcDeviceQualifierDescriptor::Construct(TUint8 aDeviceClass, TUint8 aDeviceSubClass,

											   TUint8 aDeviceProtocol, TUint8 aMaxPacketSize0,

											   TUint8 aNumConfigurations, TUint8 aReserved)

	{

	iBuf.SetMax();

	SetBufferPointer(iBuf);

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

	iBuf[1] = KUsbDescType_DeviceQualifier;					// bDescriptorType

	SetWord(2, KUsbcUsbVersion);							// bcdUSB

	iBuf[4] = aDeviceClass;									// bDeviceClass

	iBuf[5] = aDeviceSubClass;								// bDeviceSubClass

	iBuf[6] = aDeviceProtocol;								// bDeviceProtocol

	iBuf[7] = aMaxPacketSize0;								// bMaxPacketSize0

	iBuf[8] = aNumConfigurations;							// bNumConfigurations

	if (aReserved) aReserved = 0;

	iBuf[9] = aReserved;									// Reserved for future use, must be zero

	iEp0Size_Fs = aMaxPacketSize0;

	return KErrNone;

	}

void TUsbcDeviceQualifierDescriptor::UpdateFs()

	{

	// Here we do exactly the opposite of what's done in the Device descriptor (as this one's

	// documenting the 'other than the current speed').

	SetByte(7, 64);											// bMaxPacketSize0

	}

void TUsbcDeviceQualifierDescriptor::UpdateHs()

	{

	// Here we do exactly the opposite of what's done in the Device descriptor (as this one's

	// documenting the 'other than the current speed').

	SetByte(7, iEp0Size_Fs);								// bMaxPacketSize0

	}

// --- TUsbcConfigDescriptor

TUsbcConfigDescriptor::TUsbcConfigDescriptor()

	: iBuf()

	{

	}

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

												  TBool aRemoteWakeup, TUint16 aMaxPower)

	{

	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, TUint16 aMaxPower)

	{

	iBuf.SetMax();

	SetBufferPointer(iBuf);

	iBuf[0] = 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] = 0x80 |

		(aSelfPowered ? KUsbDevAttr_SelfPowered : 0) |

		(aRemoteWakeup ? KUsbDevAttr_RemoteWakeup : 0);		// bmAttributes (bit 7 always 1)

	if (aMaxPower > 510)

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

	return KErrNone;

	}

// --- TUsbcInterfaceDescriptor

TUsbcInterfaceDescriptor::TUsbcInterfaceDescriptor()

	: iBuf()

	{

	}

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

														TInt aNumEndpoints, const TUsbcClassInfo& aClassInfo)

	{

	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)

	{

	iBuf.SetMax();

	SetBufferPointer(iBuf);

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

	iBuf[1] = KUsbDescType_Interface;						// bDescriptorType

	iBuf[2] = aInterfaceNumber;								// bInterfaceNumber

	iBuf[3] = aAlternateSetting;							// bAlternateSetting

	iBuf[4] = aNumEndpoints;								// bNumEndpoints

	iBuf[5] = aClassInfo.iClassNum;							// bInterfaceClass

	iBuf[6] = aClassInfo.iSubClassNum;						// bInterfaceSubClass

	iBuf[7] = aClassInfo.iProtocolNum;						// bInterfaceProtocol

	iBuf[8] = 0;											// iInterface

	return KErrNone;

	}

// --- TUsbcEndpointDescriptorBase

TUsbcEndpointDescriptorBase::TUsbcEndpointDescriptorBase()

	{

	}

TInt TUsbcEndpointDescriptorBase::Construct(const TUsbcEndpointInfo& aEpInfo)

	{

	//  Adjust FS/HS endpoint sizes

	if (aEpInfo.AdjustEpSizes(iEpSize_Fs, iEpSize_Hs) != KErrNone)

		{

		}

	//  Adjust HS endpoint size for additional transactions

	if ((aEpInfo.iType == KUsbEpTypeIsochronous) || (aEpInfo.iType == KUsbEpTypeInterrupt))

		{

		if ((aEpInfo.iTransactions > 0) && (aEpInfo.iTransactions < 3))

			{

			// Bits 12..11 specify the number of additional transactions per microframe

			iEpSize_Hs |= (aEpInfo.iTransactions << 12);

			}

		else if (aEpInfo.iTransactions != 0)

			{

			}

		}

	//  Adjust HS polling interval

	TUsbcEndpointInfo info(aEpInfo);						// create local writeable copy

	if (info.AdjustPollInterval() != KErrNone)

		{

		}

	iInterval_Fs = info.iInterval;

	iInterval_Hs = info.iInterval_Hs;

	return KErrNone;

	}

void TUsbcEndpointDescriptorBase::UpdateFs()

	{

	// (TUsbcEndpointDescriptorBase's FS/HS endpoint sizes and interval values got

	//  adjusted in its Construct() method.)

	SetWord(4, iEpSize_Fs);									// wMaxPacketSize

	SetByte(6, iInterval_Fs);								// bInterval

	}

void TUsbcEndpointDescriptorBase::UpdateHs()

	{

	// (TUsbcEndpointDescriptorBase's FS/HS endpoint sizes and interval values get

	//  adjusted in its Construct() method.)

	SetWord(4, iEpSize_Hs);									// wMaxPacketSize

	SetByte(6, iInterval_Hs);								// bInterval

	}

// --- TUsbcEndpointDescriptor

TUsbcEndpointDescriptor::TUsbcEndpointDescriptor()

	: iBuf()

	{

	}

TUsbcEndpointDescriptor* TUsbcEndpointDescriptor::New(TUint8 aEndpointAddress,

													  const TUsbcEndpointInfo& aEpInfo)

	{

	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)

	{

	(void) TUsbcEndpointDescriptorBase::Construct(aEpInfo);	// Init Base class

	iBuf.SetMax();

	SetBufferPointer(iBuf);

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

	iBuf[1] = KUsbDescType_Endpoint;						// bDescriptorType