// 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/activecontrol.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"									

#include "usblib.h"											// Helpers

#include "config.h"

#include "activecontrol.h"

#include "apitests.h"

#include "activerw.h"

void StartMassStorage(RDEVCLIENT* aPort);

void StopMassStorage(RDEVCLIENT* aPort);

enum Ep0Requests

	{

	EStop = 0x1,

	EVersion = 0x10,

	ETestParam = 0x20,

	ETestResult = 0x30,

	ETestFail = 0x40,

	ETestConnect = 0x50,

	ETestDisconnect = 0x60,

	ETestMassStorage = 0x70,

	ETestIdleCounter = 0x80,

	};

extern RTest test;

extern TBool gVerbose;

extern TBool gSkip;

extern TBool gTempTest;

extern TBool gStopOnFail;

extern TBool gAltSettingOnNotify;

extern TInt gSoakCount;

extern CActiveRW* gRW[KMaxConcurrentTests];				// the USB read/write active object

extern IFConfigPtr gInterfaceConfig [128] [KMaxInterfaceSettings];

extern TInt gActiveTestCount;

#ifdef USB_SC

extern RChunk gChunk;

#endif

TInt firstBulkOutEndpoint = -1;

_LIT(KTestIdleCounterChunkName, "TestIdleCounter");

_LIT(KTestIdleCounterPanic, "IdleCounter");

enum TTestIdleCounterPanic

	{

	ETestIdleCounterWrongCommand

	};

enum TTestIdleCounterCommand

	{

	ETestIdleCounterDoNothing,

	ETestIdleCounterReset,

	ETestIdleCounterClose

	};

struct TTestIdleCounter

	{

	volatile TInt64 iCounter;

	volatile TTestIdleCounterCommand iCommand;

	};

TInt IdleCounterThread(TAny*)

	{

	TInt r;

	//

	RThread().SetPriority(EPriorityAbsoluteVeryLow);

	//

	RChunk chunk;

	r = chunk.CreateGlobal(KTestIdleCounterChunkName,

			sizeof(struct TTestIdleCounter),

			sizeof(struct TTestIdleCounter) + 1);

	if (r == KErrNone)

		{

		struct TTestIdleCounter* counter = (struct TTestIdleCounter*) chunk.Base();

		counter->iCounter = 0;

		counter->iCommand = ETestIdleCounterDoNothing;

		//

		FOREVER

			{

			TInt command = counter->iCommand;

			if (command == ETestIdleCounterReset)

				{

				counter->iCounter = 0;

				counter->iCommand = ETestIdleCounterDoNothing;

				}

			else if (command == ETestIdleCounterClose)

				{

				break;

				}

			else if (command != ETestIdleCounterDoNothing)

				{

				RThread().Panic(KTestIdleCounterPanic, ETestIdleCounterWrongCommand);

				}

			//

			counter->iCounter++;

			}

		//

		chunk.Close();

		}

	return r;

	}

//

// --- class CActiveControl ---------------------------------------------------------

//

CActiveControl::CActiveControl(CConsoleBase* aConsole, TDes * aConfigFile, TDes * aScriptFile)

	: CActive(EPriorityNormal),

	  iConsole(aConsole),

	  iSoftwareConnect(EFalse),

	  iSupportResourceAllocationV2(EFalse),

	  iHighSpeed(EFalse),

	  iConfigFileName(aConfigFile),

	  iScriptFileName(aScriptFile),

	  iEp0PacketSize(0)

	{}

CActiveControl* CActiveControl::NewLC(CConsoleBase* aConsole, TDes * aConfigFile, TDes * aScriptFile)

	{

	CActiveControl* self = new (ELeave) CActiveControl(aConsole, aConfigFile, aScriptFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CActiveControl* CActiveControl::NewL(CConsoleBase* aConsole, TDes * aConfigFile, TDes * aScriptFile)

	{

	CActiveControl* self = NewLC(aConsole, aConfigFile, aScriptFile);

	CleanupStack::Pop();

	return self;

	}

void CActiveControl::ConstructL()

	{

	CActiveScheduler::Add(this);

	TInt r;

	User::LeaveIfError(iFs.Connect());

	test.Start (_L("Configuration"));

	test_Compare(iConfigFileName->Length(),!=,0);

	iTimer.CreateLocal();

	iPending = EPendingNone;

	test.Next (_L("Open configuration file"));

	// set the session path to use the ROM if no drive specified

	r=iFs.SetSessionPath(_L("Z:\\test\\"));

	test_KErrNone(r);

	r = iConfigFile.Open(iFs, * iConfigFileName, EFileShareReadersOnly | EFileStreamText | EFileRead);

	test_KErrNone(r);

	TUSB_VERBOSE_PRINT1("Configuration file %s Opened successfully", iConfigFileName->PtrZ());

	test.Next (_L("Process configuration file"));

	test(ProcessConfigFile (iConfigFile,iConsole,&iLddPtr));

	iConfigFile.Close();

	test.Next (_L("LDD in configuration file"));

	test_NotNull(iLddPtr);

	LDDConfigPtr lddPtr = iLddPtr;

	TInt nextPort = 0;

	while (lddPtr != NULL)

		{

		// Load logical driver (LDD)

		// (There's no physical driver (PDD) with USB: it's a kernel extension DLL which

		//  was already loaded at boot time.)

		test.Next (_L("Loading USB LDD"));

		TUSB_VERBOSE_PRINT1("Loading USB LDD ",lddPtr->iName.PtrZ());

		r = User::LoadLogicalDevice(lddPtr->iName);

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

		IFConfigPtr ifPtr = lddPtr->iIFPtr;

		test.Next (_L("Opening Channels"));

		for (TInt portNumber = nextPort; portNumber < nextPort+lddPtr->iNumChannels; portNumber++)

			{

			test_Compare(lddPtr->iNumChannels,>,0);

			// Open USB channel

			r = iPort[portNumber].Open(0);

			test_KErrNone(r);

			TUSB_VERBOSE_PRINT("Successfully opened USB port");

			// Query the USB device/Setup the USB interface

			if (portNumber == nextPort)

				{

				// Change some descriptors to contain suitable values

				SetupDescriptors(lddPtr, &iPort[portNumber]);

				}

			if (portNumber == 0)

				{

				QueryUsbClientL(lddPtr, &iPort[portNumber]);

				}

			test_NotNull(ifPtr);

			if (iSupportResourceAllocationV2)

				{

				PopulateInterfaceResourceAllocation(ifPtr, portNumber);

				}

			IFConfigPtr defaultIfPtr = ifPtr;

			SetupInterface(&ifPtr,portNumber);

			#ifdef USB_SC

			RChunk *tChunk = &gChunk;

			test_KErrNone(iPort[portNumber].FinalizeInterface(tChunk));

			#endif

			if (!iSupportResourceAllocationV2)

				{

				// 	allocate endpoint DMA and double buffering for all endpoints on default interface when using resource allocation v1 api

				for (TUint8 i = 1; i <= defaultIfPtr->iInfoPtr->iTotalEndpointsUsed; i++)

					{

					defaultIfPtr->iEpDMA[i-1] ? AllocateEndpointDMA(&iPort[portNumber],(TENDPOINTNUMBER)i) : DeAllocateEndpointDMA(&iPort[portNumber],(TENDPOINTNUMBER)i);

					#ifndef USB_SC

					defaultIfPtr->iEpDoubleBuff[i-1] ? AllocateDoubleBuffering(&iPort[portNumber],(TENDPOINTNUMBER)i) : DeAllocateDoubleBuffering(&iPort[portNumber],(TENDPOINTNUMBER)i);

					#endif

					}				

				}

			}

		iTotalChannels += lddPtr->iNumChannels;

		nextPort += lddPtr->iNumChannels;	

		lddPtr = lddPtr->iPtrNext;	

		}

	TUSB_VERBOSE_PRINT("All Interfaces and Alternate Settings successfully set up");

	test.Next (_L("Start Idle Counter Thread"));

	r = iIdleCounterThread.Create(_L("IdleCounter"), IdleCounterThread, KDefaultStackSize, KMinHeapSize, KMinHeapSize, NULL);

	test_KErrNone(r);

	iIdleCounterThread.Resume();

	// Allow some time for low-priority counter process

	User::After(100000); // 0.1 second

	r = iIdleCounterChunk.OpenGlobal(KTestIdleCounterChunkName, EFalse);

	test_KErrNone(r);

	iIdleCounter = (struct TTestIdleCounter*) iIdleCounterChunk.Base();

	test_NotNull(iIdleCounter);

	// Allow some time for low-priority counter process

	User::After(100000); // 0.1 second

	TInt64 val1 = iIdleCounter->iCounter;

	User::After(1000000); // 1 second

	TInt64 val2 = iIdleCounter->iCounter;

	TUSB_PRINT1("Idle Counter when test inactive: %Ldinc/ms", (val2 - val1) / 1000);

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

	r = ReEnumerate();

	test_KErrNone(r);

	TUSB_VERBOSE_PRINT("Device successfully re-enumerated\n");

	if (iLddPtr->iHighSpeed && !gSkip)

		{

		test.Next (_L("High Speed"));

		test(iHighSpeed);	

		}

	test.Next (_L("Create Notifiers"));

	for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)

		{

		// Create device state active object

		iDeviceStateNotifier[portNumber] = CActiveDeviceStateNotifier::NewL(iConsole, &iPort[portNumber], portNumber);

		test_NotNull(iDeviceStateNotifier[portNumber]);

		iDeviceStateNotifier[portNumber]->Activate();

		TUSB_VERBOSE_PRINT("Created device state notifier");

		// Create endpoint stall status active object

		iStallNotifier[portNumber] = CActiveStallNotifier::NewL(iConsole, &iPort[portNumber]);

		test_NotNull(iStallNotifier[portNumber]);

		iStallNotifier[portNumber]->Activate();

		TUSB_VERBOSE_PRINT("Created stall notifier");

		TestInvalidSetInterface (&iPort[portNumber],iNumInterfaceSettings[portNumber]);			

		TestInvalidReleaseInterface (&iPort[portNumber],iNumInterfaceSettings[portNumber]);

		}

	test.Next (_L("Endpoint Zero Max Packet Sizes"));

	TUint ep0Size = iPort[0].EndpointZeroMaxPacketSizes();

	switch (ep0Size)

		{

		case KUsbEpSize8 :

			iEp0PacketSize = 8;

			break;

		case KUsbEpSize16 :

			iEp0PacketSize = 16;

			break;

		case KUsbEpSize32 :

			iEp0PacketSize = 32;

			break;

		case KUsbEpSize64 :

			iEp0PacketSize = 64;

			break;

		default:

			iEp0PacketSize = 0;

			break;		

		}

	test_Compare(iEp0PacketSize,>,0);

	test.Next (_L("Set Device Control"));

	r = iPort[0].SetDeviceControl();

	test_KErrNone(r);

	#ifdef USB_SC

	r = iPort[0].OpenEndpoint(iEp0Buf,0);

	test_KErrNone(r);

	#endif

	test.End();

	}

void CActiveControl::ReConnect()

	{

	TInt r;

	test.Start (_L("Reconnecting USB"));

	LDDConfigPtr lddPtr = iLddPtr;

	TInt nextPort = 0;

	while (lddPtr != NULL)

		{

		IFConfigPtr ifPtr = lddPtr->iIFPtr;

		test.Next (_L("Opening Channels"));

		for (TInt portNumber = nextPort; portNumber < nextPort+lddPtr->iNumChannels; portNumber++)

			{

			// Open USB channel

			r = iPort[portNumber].Open(0);

			test_KErrNone(r);

			TUSB_VERBOSE_PRINT("Successfully opened USB port");

			// Query the USB device/Setup the USB interface

			if (portNumber == nextPort)

				{

				// Change some descriptors to contain suitable values

				SetupDescriptors(lddPtr, &iPort[portNumber]);

				}

			IFConfigPtr defaultIfPtr = ifPtr;

			SetupInterface(&ifPtr,portNumber);

			#ifdef USB_SC

			RChunk *tChunk = &gChunk;

			test_KErrNone(iPort[portNumber].FinalizeInterface(tChunk));

			#endif

			if (!iSupportResourceAllocationV2)

				{

				// 	allocate endpoint DMA and double buffering for all endpoints on default interface with resource allocation v1 api

				for (TUint8 i = 1; i <= defaultIfPtr->iInfoPtr->iTotalEndpointsUsed; i++)

					{

					defaultIfPtr->iEpDMA[i-1] ? AllocateEndpointDMA(&iPort[portNumber],(TENDPOINTNUMBER)i) : DeAllocateEndpointDMA(&iPort[portNumber],(TENDPOINTNUMBER)i);

					#ifndef USB_SC

					defaultIfPtr->iEpDoubleBuff[i-1] ? AllocateDoubleBuffering(&iPort[portNumber],(TENDPOINTNUMBER)i) : DeAllocateDoubleBuffering(&iPort[portNumber],(TENDPOINTNUMBER)i);

					#endif

					}

				}				

			}

		nextPort += lddPtr->iNumChannels;	

		lddPtr = lddPtr->iPtrNext;	

		}

	TUSB_VERBOSE_PRINT("All Interfaces and Alternate Settings successfully set up");

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

	r = ReEnumerate();

	test_KErrNone(r);

	TUSB_VERBOSE_PRINT("Device successfully re-enumerated\n");

	for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)

		{

		// Create device state active object

		iDeviceStateNotifier[portNumber] = CActiveDeviceStateNotifier::NewL(iConsole, &iPort[portNumber], portNumber);

		test_NotNull(iDeviceStateNotifier[portNumber]);

		iDeviceStateNotifier[portNumber]->Activate();

		TUSB_VERBOSE_PRINT("Created device state notifier");

		// Create endpoint stall status active object

		iStallNotifier[portNumber] = CActiveStallNotifier::NewL(iConsole, &iPort[portNumber]);

		test_NotNull(iStallNotifier[portNumber]);

		iStallNotifier[portNumber]->Activate();

		TUSB_VERBOSE_PRINT("Created stall notifier");

		if (portNumber == 0)

			{

			test.Next (_L("Set Device Control"));

			r = iPort[portNumber].SetDeviceControl();

			test_KErrNone(r);

			#ifdef USB_SC

			r = iPort[portNumber].OpenEndpoint(iEp0Buf,0);

			test_KErrNone(r);

			#endif

			}

		}

	test.End();

	}

void CActiveControl::FillEndpointsResourceAllocation(IFConfigPtr aIfCfg)

	{

	#ifdef USB_SC

		TUsbcScInterfaceInfo* iInfoPtr = aIfCfg->iInfoPtr;

	#else

		TUsbcInterfaceInfo* iInfoPtr = aIfCfg->iInfoPtr;

	#endif

	// 	fill resource allocation info in the endpoint info with resource allocation v2

	for (TUint8 i = 1; i <= iInfoPtr->iTotalEndpointsUsed; i++)

		{

		if (aIfCfg->iEpDMA[i-1])

			{

			iInfoPtr->iEndpointData[i-1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DMA;

			}

		else

			{

			iInfoPtr->iEndpointData[i-1].iFeatureWord1 &= (~KUsbcEndpointInfoFeatureWord1_DMA);

			}

		#ifndef USB_SC

		if (aIfCfg->iEpDoubleBuff[i-1])

			{

			iInfoPtr->iEndpointData[i-1].iFeatureWord1 |= KUsbcEndpointInfoFeatureWord1_DoubleBuffering;

			}

		else

			{

			iInfoPtr->iEndpointData[i-1].iFeatureWord1 &= (~KUsbcEndpointInfoFeatureWord1_DoubleBuffering);

			}

		#endif

		}	

	}

// all alternative settings of the interface 'aFirstIfCfg' will be populated

void CActiveControl::PopulateInterfaceResourceAllocation(IFConfigPtr aFirstIfCfg, TInt aPortNumber)

	{

	FillEndpointsResourceAllocation(aFirstIfCfg);

	IFConfigPtr ifCfgPtr = aFirstIfCfg->iPtrNext;

	while (ifCfgPtr != NULL)

		{

		if (ifCfgPtr->iAlternateSetting)

			{

			FillEndpointsResourceAllocation(ifCfgPtr);

			ifCfgPtr = ifCfgPtr->iPtrNext;

			}

		else

			{

			ifCfgPtr = NULL;

			}

		}

	}

void CActiveControl::SetupInterface(IFConfigPtr* aIfPtr, TInt aPortNumber)

	{

	test.Start (_L("Setup Interface"));

	// first of all set the default interface	

	TUSB_PRINT2 ("Set Default Interface with %d endpoints bandwidth 0x%x",(*aIfPtr)->iInfoPtr->iTotalEndpointsUsed,(*aIfPtr)->iBandwidthIn | (*aIfPtr)->iBandwidthOut);

	#ifdef USB_SC

	TUsbcScInterfaceInfoBuf ifc = *((*aIfPtr)->iInfoPtr);

	TInt r = iPort[aPortNumber].SetInterface(0, ifc);

	#else