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

// e32test/usb/t_usb_device/src/apitests.cpp

// USB Test Program T_USB_DEVICE, functional part.

// Device-side part, to work against T_USB_HOST running on the host.

//

#include "general.h"									// CActiveControl, CActiveRW

#include "config.h"

#include "usblib.h"										// Helpers

extern RTest test;

extern TBool gVerbose;

extern TBool gSkip;

extern TBool gTempTest;

_LIT16(KString_one, "Arbitrary String Descriptor Test String 1");

_LIT16(KString_two, "Another Arbitrary String Descriptor Test String");

void SetupDescriptors(LDDConfigPtr aLddPtr,RDEVCLIENT* aPort, TUint16 aPid = 0)

	{

	// === Device Descriptor

	test.Start(_L("Set up descriptors"));

	test.Next(_L("GetDeviceDescriptorSize"));

	TInt deviceDescriptorSize = 0;

	aPort->GetDeviceDescriptorSize(deviceDescriptorSize);

	test_Equal(KUsbDescSize_Device,static_cast<TUint>(deviceDescriptorSize));

	test.Next(_L("GetDeviceDescriptor"));

	TBuf8<KUsbDescSize_Device> deviceDescriptor;

	TInt r = aPort->GetDeviceDescriptor(deviceDescriptor);

	test_KErrNone(r);

	test.Next(_L("SetDeviceDescriptor"));

	const TInt KUsbSpecOffset = 2;

	const TInt KUsbDevClass = 4;

	const TInt KUsbDevSubClass = 5;

	const TInt KUsbDevProtocol = 6;

	const TInt KUsbVendorIdOffset = 8;

	const TInt KUsbProductIdOffset = 10;

	const TInt KUsbDevReleaseOffset = 12;

	// Change the USB spec number

	deviceDescriptor[KUsbSpecOffset]   = LoByte(aLddPtr->iSpec);

	deviceDescriptor[KUsbSpecOffset+1] = HiByte(aLddPtr->iSpec);

	// Change the Device Class, SubClass and Protocol to zero so that they are not device specific

	// and diferent clases can used on different interfaces

	deviceDescriptor[KUsbDevClass] = 0;

	deviceDescriptor[KUsbDevSubClass] = 0;

	deviceDescriptor[KUsbDevProtocol] = 0;

	// Change the device vendor ID (VID)

	deviceDescriptor[KUsbVendorIdOffset]   = LoByte(aLddPtr->iVid);			// little endian!

	deviceDescriptor[KUsbVendorIdOffset+1] = HiByte(aLddPtr->iVid);

	// Change the device product ID (PID)

	if (aPid != 0)

		deviceDescriptor[KUsbProductIdOffset]	= LoByte(aPid);		// little endian!

		}

	else

		{

		deviceDescriptor[KUsbProductIdOffset]	= LoByte(aLddPtr->iPid);		// little endian!

		}

	// Change the device release number

	deviceDescriptor[KUsbDevReleaseOffset]	 = LoByte(aLddPtr->iRelease);	// little endian!

	deviceDescriptor[KUsbDevReleaseOffset+1] = HiByte(aLddPtr->iRelease);

	r = aPort->SetDeviceDescriptor(deviceDescriptor);

	test_KErrNone(r);

	if (!gSkip)

		{

		test.Next(_L("GetDeviceDescriptor()"));

		TBuf8<KUsbDescSize_Device> descriptor2;

		r = aPort->GetDeviceDescriptor(descriptor2);

		test_KErrNone(r);

		test.Next(_L("Compare device descriptor with value set"));

		r = descriptor2.Compare(deviceDescriptor);

		}

	// === Configuration Descriptor

	test.Next(_L("GetConfigurationDescriptorSize"));

	TInt configDescriptorSize = 0;

	aPort->GetConfigurationDescriptorSize(configDescriptorSize);

	test_Equal(KUsbDescSize_Config,static_cast<TUint>(configDescriptorSize));

	test.Next(_L("GetConfigurationDescriptor"));

	TBuf8<KUsbDescSize_Config> configDescriptor;

	r = aPort->GetConfigurationDescriptor(configDescriptor);

	test_KErrNone(r);

	test.Next(_L("SetConfigurationDescriptor"));

	// Change Self Power and Remote Wakeup

	const TInt KUsbAttributesOffset = 7;

	const TUint8 KUsbAttributeDefault = 0x80;

	const TUint8 KUsbAttributeSelfPower = 0x40;

	const TUint8 KUsbAttributeRemoteWakeup = 0x20;

													| (aLddPtr->iRemoteWakeup ? KUsbAttributeRemoteWakeup : 0);

	// Change the reported max power

	// 100mA (= 2 * 0x32) is the highest value allowed for a bus-powered device.

	const TInt KUsbMaxPowerOffset = 8;

	configDescriptor[KUsbMaxPowerOffset] = aLddPtr->iMaxPower;

	r = aPort->SetConfigurationDescriptor(configDescriptor);

	test_KErrNone(r);

	if (!gSkip)

		{

		test.Next(_L("GetConfigurationDescriptor()"));

		TBuf8<KUsbDescSize_Config> descriptor2;

		r = aPort->GetConfigurationDescriptor(descriptor2);

		test_KErrNone(r);

		test.Next(_L("Compare configuration desc with value set"));

		r = descriptor2.Compare(configDescriptor);

		test_KErrNone(r);

		}

	// === String Descriptors

	test.Next(_L("SetStringDescriptor"));

	// Set up any standard string descriptors that were defined in the xml config

	if (aLddPtr->iManufacturer)

		{

		r = aPort->SetManufacturerStringDescriptor(* aLddPtr->iManufacturer);

		test_KErrNone(r);

		}

	if (aLddPtr->iProduct)

		{

		r = aPort->SetProductStringDescriptor(* aLddPtr->iProduct);

		test_KErrNone(r);

		}

	if (aLddPtr->iSerialNumber)

		{

		r = aPort->SetSerialNumberStringDescriptor(* aLddPtr->iSerialNumber);

		test_KErrNone(r);

		}

	// Set up two arbitrary string descriptors, which can be queried

	// manually from the host side for testing purposes

	TBuf16<KUsbStringDescStringMaxSize / 2> wr_str(KString_one);

	r = aPort->SetStringDescriptor(stridx1, wr_str);

	test_KErrNone(r);

	wr_str.FillZ(wr_str.MaxLength());

	wr_str = KString_two;

	r = aPort->SetStringDescriptor(stridx2, wr_str);

	test_KErrNone(r);

	test.End();

	}

static void TestDeviceQualifierDescriptor(RDEVCLIENT* aPort)

	{

	test.Start(_L("Device_Qualifier Descriptor Manipulation"));

	test.Next(_L("GetDeviceQualifierDescriptor()"));

	TBuf8<KUsbDescSize_DeviceQualifier> descriptor;

	TInt r = aPort->GetDeviceQualifierDescriptor(descriptor);

	test_KErrNone(r);

	test.Next(_L("SetDeviceQualifierDescriptor()"));

	// Change the USB spec number to 3.00

	descriptor[KDevDesc_SpecOffset]   = 0x00;

	descriptor[KDevDesc_SpecOffset+1] = 0x03;

	// Change the device class, subclass and protocol codes

	descriptor[KDevDesc_DevClassOffset]    = 0xA1;

	descriptor[KDevDesc_DevSubClassOffset] = 0xB2;

	descriptor[KDevDesc_DevProtocolOffset] = 0xC3;

	r = aPort->SetDeviceQualifierDescriptor(descriptor);

	test_KErrNone(r);

	test.Next(_L("GetDeviceQualifierDescriptor()"));

	TBuf8<KUsbDescSize_DeviceQualifier> descriptor2;

	r = aPort->GetDeviceQualifierDescriptor(descriptor2);

	test_KErrNone(r);

	test.Next(_L("Compare Device_Qualifier desc with value set"));

	r = descriptor2.Compare(descriptor);

	test_Equal(0,r);

	test.End();

	}

static void	TestOtherSpeedConfigurationDescriptor(RDEVCLIENT* aPort)

	{

	test.Start(_L("Other_Speed_Configuration Desc Manipulation"));

	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor;

	TInt r = aPort->GetOtherSpeedConfigurationDescriptor(descriptor);

	test_KErrNone(r);

	test.Next(_L("SetOtherSpeedConfigurationDescriptor()"));

	// Invert Remote-Wakup support

	descriptor[KConfDesc_AttribOffset] = (descriptor[KConfDesc_AttribOffset] ^ KUsbDevAttr_RemoteWakeup);

	// Change the reported max power to 330mA (2 * 0xA5)

	descriptor[KConfDesc_MaxPowerOffset] = 0xA5;

	r = aPort->SetOtherSpeedConfigurationDescriptor(descriptor);

	test_KErrNone(r);

	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor2;

	r = aPort->GetOtherSpeedConfigurationDescriptor(descriptor2);

	test_KErrNone(r);

	test.Next(_L("Compare O_S_Config desc with value set"));

	r = descriptor2.Compare(descriptor);

	test_KErrNone(r);

	test.End();

	}

static void TestInterfaceDescriptor(RDEVCLIENT* aPort, TInt aNumSettings)

	{

	test.Start(_L("Interface Descriptor Manipulation"));

	// For all settings

	TInt desc_size = 0;

	TInt r = 0;

	TBuf8<KUsbDescSize_Interface> descriptor;

	TBuf8<KUsbDescSize_Interface> descriptor2;

	for (TInt i =0; i < aNumSettings; i++)

		{

		test.Next(_L("GetInterfaceDescriptorSize()"));

		r = aPort->GetInterfaceDescriptorSize(i, desc_size);

		if (r != KErrNone)

			{

			}

		test_KErrNone(r);

		test_Equal(KUsbDescSize_Interface,static_cast<TUint>(desc_size));

		test.Next(_L("GetInterfaceDescriptor()"));

		r = aPort->GetInterfaceDescriptor(i, descriptor);

		test_KErrNone(r);

		test.Next(_L("SetInterfaceDescriptor()"));

		// Change the interface protocol to 0x78(+)

		TUint8 prot = 0x78;

		if (descriptor[KIfcDesc_ProtocolOffset] == prot)

			prot++;

		descriptor[KIfcDesc_ProtocolOffset] = prot;

		r = aPort->SetInterfaceDescriptor(i, descriptor);

		test_KErrNone(r);

		test.Next(_L("GetInterfaceDescriptor()"));

		r = aPort->GetInterfaceDescriptor(i, descriptor2);

		test_KErrNone(r);

		test.Next(_L("Compare interface descriptor with value set"));

		r = descriptor2.Compare(descriptor);

		test_KErrNone(r);

		}

	test.Next(_L("GetInterfaceDescriptor()"));

	r = aPort->GetInterfaceDescriptor(aNumSettings, descriptor);

	test_Equal(KErrNotFound,r);

	test.Next(_L("SetInterfaceDescriptor()"));

	r = aPort->SetInterfaceDescriptor(aNumSettings, descriptor);

	test_Equal(KErrNotFound,r);

	test.End();

	}

static void TestClassSpecificDescriptors(RDEVCLIENT* aPort)

	{

	test.Start(_L("Class-specific Descriptor Manipulation"));

	// First a class-specific Interface descriptor

	test.Next(_L("SetCSInterfaceDescriptorBlock()"));

	// choose arbitrary new descriptor size

	const TInt KUsbDescSize_CS_Interface = KUsbDescSize_Interface + 10;

	TBuf8<KUsbDescSize_CS_Interface> cs_ifc_descriptor;

	cs_ifc_descriptor.FillZ(cs_ifc_descriptor.MaxLength());

	cs_ifc_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Interface;

	cs_ifc_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Interface;

	TInt r = aPort->SetCSInterfaceDescriptorBlock(0, cs_ifc_descriptor);

	test_KErrNone(r);

	test.Next(_L("GetCSInterfaceDescriptorBlockSize()"));

	TInt desc_size = 0;

	r = aPort->GetCSInterfaceDescriptorBlockSize(0, desc_size);

	test_KErrNone(r);

	test_Equal(KUsbDescSize_CS_Interface,desc_size);

	test.Next(_L("GetCSInterfaceDescriptorBlock()"));

	TBuf8<KUsbDescSize_CS_Interface> descriptor;

	r = aPort->GetCSInterfaceDescriptorBlock(0, descriptor);

	test_KErrNone(r);

	test.Next(_L("Compare CS ifc descriptor with value set"));

	r = descriptor.Compare(cs_ifc_descriptor);

	test_KErrNone(r);

	// Next a class-specific Endpoint descriptor

	test.Next(_L("SetCSEndpointDescriptorBlock()"));

	// choose arbitrary new descriptor size

	const TInt KUsbDescSize_CS_Endpoint = KUsbDescSize_Endpoint + 5;

	TBuf8<KUsbDescSize_CS_Endpoint> cs_ep_descriptor;

	cs_ep_descriptor.FillZ(cs_ep_descriptor.MaxLength());

	cs_ep_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Endpoint;

	cs_ep_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Endpoint;

	r = aPort->SetCSEndpointDescriptorBlock(0, 2, cs_ep_descriptor);

	test_KErrNone(r);

	test.Next(_L("GetCSEndpointDescriptorBlockSize()"));

	r = aPort->GetCSEndpointDescriptorBlockSize(0, 2, desc_size);

	test_KErrNone(r);

	test_Equal(KUsbDescSize_CS_Endpoint,desc_size);

	test.Next(_L("GetCSEndpointDescriptorBlock()"));

	TBuf8<KUsbDescSize_CS_Endpoint> descriptor2;

	r = aPort->GetCSEndpointDescriptorBlock(0, 2, descriptor2);

	test_KErrNone(r);

	test.Next(_L("Compare CS ep descriptor with value set"));

	r = descriptor2.Compare(cs_ep_descriptor);

	test_KErrNone(r);

	test.End();

	}

void TestEndpointDescriptor(RDEVCLIENT* aPort,TInt aIfSetting, TInt aEpNumber,TUsbcEndpointInfo aEpInfo)

	{

	test.Start(_L("Endpoint Descriptor Manipulation"));

	TBuf8<KUsbDescSize_AudioEndpoint> epDescriptor;

	TInt desc_size;

	TInt r = aPort->GetEndpointDescriptorSize(aIfSetting, aEpNumber, desc_size);

	test_KErrNone(r);

	test_Equal(KUsbDescSize_Endpoint + aEpInfo.iExtra,static_cast<TUint>(desc_size));

	r = aPort->GetEndpointDescriptor(aIfSetting, aEpNumber, epDescriptor);

	test_KErrNone(r);

	test(((aEpInfo.iDir & KUsbEpDirIn) && (epDescriptor[KEpDesc_AddressOffset] & 0x80) ||

		!(aEpInfo.iDir & KUsbEpDirIn) && !(epDescriptor[KEpDesc_AddressOffset] & 0x80)) &&

			EpTypeMask2Value(aEpInfo.iType) == (TUint)(epDescriptor[KEpDesc_AttributesOffset] & 0x03) &&

			aEpInfo.iInterval == epDescriptor[KEpDesc_IntervalOffset]);

	// Change the endpoint poll interval

	TUint8 ival = 0x66;

	if (epDescriptor[KEpDesc_IntervalOffset] == ival)

		ival++;

	TUint8 saveAddr = 0;										// save the address

	if (aEpInfo.iExtra > 0)

		{

		saveAddr = epDescriptor[KEpDesc_SynchAddressOffset];

		TUint8 addr = 0x85;										// bogus address

		if (epDescriptor[KEpDesc_SynchAddressOffset] == addr)

			addr++;

		epDescriptor[KEpDesc_SynchAddressOffset] = addr;

		}

	epDescriptor[KEpDesc_IntervalOffset] = ival;

	r = aPort->SetEndpointDescriptor(aIfSetting, aEpNumber, epDescriptor);

	test_KErrNone(r);

	TBuf8<KUsbDescSize_AudioEndpoint> descriptor2;

	r = aPort->GetEndpointDescriptor(aIfSetting, aEpNumber, descriptor2);

	test_KErrNone(r);

	r = descriptor2.Compare(epDescriptor);

	test_KErrNone(r);

	if (aEpInfo.iExtra > 0)

		{

		// Restore the endpoint synch address

		epDescriptor[KEpDesc_SynchAddressOffset] = saveAddr;

		}

	// Restore the endpoint poll interval

	epDescriptor[KEpDesc_IntervalOffset] = aEpInfo.iInterval;

	r = aPort->SetEndpointDescriptor(aIfSetting, aEpNumber, epDescriptor);

	test_KErrNone(r);

	test.End();

	}

static void TestStandardStringDescriptors(RDEVCLIENT* aPort)

	{

	test.Start(_L("String Descriptor Manipulation"));

	//

	// --- LANGID code

	//

	test.Next(_L("GetStringDescriptorLangId()"));

	TUint16 rd_langid_orig;

	TInt r = aPort->GetStringDescriptorLangId(rd_langid_orig);

	test_KErrNone(r);

	test.Printf(_L("Original LANGID code: 0x%04X\n"), rd_langid_orig);

	test.Next(_L("SetStringDescriptorLangId()"));

	TUint16 wr_langid = 0x0809;								// English (UK) Language ID

	if (wr_langid == rd_langid_orig)

		wr_langid = 0x0444;									// Tatar Language ID

	r = aPort->SetStringDescriptorLangId(wr_langid);

	test_KErrNone(r);

	test.Next(_L("GetStringDescriptorLangId()"));

	TUint16 rd_langid;

	r = aPort->GetStringDescriptorLangId(rd_langid);

	test_KErrNone(r);

	test.Printf(_L("New LANGID code: 0x%04X\n"), rd_langid);

	test.Next(_L("Compare LANGID codes"));

	test_Equal(wr_langid,rd_langid);

	test.Next(_L("Restore original LANGID code"));

	r = aPort->SetStringDescriptorLangId(rd_langid_orig);

	test_KErrNone(r);

	r = aPort->GetStringDescriptorLangId(rd_langid);

	test_KErrNone(r);

	test_Equal(rd_langid_orig,rd_langid);

	//

	// --- Manufacturer string

	//

	test.Next(_L("GetManufacturerStringDescriptor()"));

	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str_orig;

	r = aPort->GetManufacturerStringDescriptor(rd_str_orig);

	test(r == KErrNone || r == KErrNotFound);

	TBool restore_string;

	if (r == KErrNone)

		{

		test.Printf(_L("Original Manufacturer string: \"%lS\"\n"), &rd_str_orig);

		restore_string = ETrue;

		}

	else

		{

		test.Printf(_L("No Manufacturer string set\n"));

		restore_string = EFalse;

		}

	test.Next(_L("SetManufacturerStringDescriptor()"));

	_LIT16(manufacturer, "Manufacturer Which Manufactures Devices");

	TBuf16<KUsbStringDescStringMaxSize / 2> wr_str(manufacturer);

	r = aPort->SetManufacturerStringDescriptor(wr_str);

	test_KErrNone(r);

	test.Next(_L("GetManufacturerStringDescriptor()"));

	TBuf16<KUsbStringDescStringMaxSize / 2> rd_str;

	r = aPort->GetManufacturerStringDescriptor(rd_str);

	test_KErrNone(r);

	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);

	test.Next(_L("Compare Manufacturer strings"));

	r = rd_str.Compare(wr_str);

	test_KErrNone(r);

	test.Next(_L("SetManufacturerStringDescriptor()"));

	_LIT16(manufacturer2, "Different Manufacturer Which Manufactures Different Devices");

	wr_str.FillZ(wr_str.MaxLength());

	wr_str = manufacturer2;

	r = aPort->SetManufacturerStringDescriptor(wr_str);

	test_KErrNone(r);

	test.Next(_L("GetManufacturerStringDescriptor()"));

	rd_str.FillZ(rd_str.MaxLength());

	r = aPort->GetManufacturerStringDescriptor(rd_str);

	test_KErrNone(r);

	test.Printf(_L("New Manufacturer string: \"%lS\"\n"), &rd_str);

	test.Next(_L("Compare Manufacturer strings"));

	r = rd_str.Compare(wr_str);

	test_KErrNone(r);

	test.Next(_L("RemoveManufacturerStringDescriptor()"));

	r = aPort->RemoveManufacturerStringDescriptor();

	test_KErrNone(r);

	r = aPort->GetManufacturerStringDescriptor(rd_str);

	test_Equal(KErrNotFound,r);

	if (restore_string)

		{

		test.Next(_L("Restore original string"));

		r = aPort->SetManufacturerStringDescriptor(rd_str_orig);