// 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/device/t_usbapi.cpp

// Overview:

// USB API Test Program (a standalone USB test program).

// API Information:

// Details:

// - Query whether the platform is operating HS (or it is connected to a HS host) or not,

// and executes the appropiate tests in each case (see RunTests() for the actual code,

// state machine enclosed for clarity):

// - Load and open an EUSBC device driver (logical device)

// - Setup the USB interface: query device capabilities, setup interface.

// - Test allocating DMA and double buffering resources with

// AllocateEndpointResource results in their use being correctly reported by

// QueryEndpointResourceUse

// - Test descriptor manipulation: validate the device, configuration,

// interface, alternate interface, endpoint and string descriptor

// manipulation.

// HS: device_qualifier and other_speed_configuation descriptors.

// - Check and validate the EndpointZeroMaxPacketSizes.

// - Quick test that calling the following APIs doesn't generate errors: device

// control, AlternateDeviceStatusNotify, EndpointStatusNotify

// - Test HaltEndpoint and ClearHaltEndpoint correctly result in endpoint

// status being reported as stalled/not stalled.

// - Test OTG extensions: OTG descriptor manipulations; set/get OTG feature

// - Close and free the logical device.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32debug.h>

#include <hal.h>

#include <d32usbc.h>

#include <d32otgdi.h>

#include "t_usblib.h"

// --- Local Top Level Variables

static RTest test(_L("T_USBAPI"));

static RDevUsbcClient gPort;

static RUsbOtgDriver gOTG;

static TBool gSupportsOtg;

static TBool gSupportsHighSpeed;

static TBool gSupportResouceAllocationV2;

static TBool gUsingHighSpeed;

static TBool gSoak;

static TChar gKeychar = 'a';

// Store the actual endpoint number(s) of our alternate interface

static TInt INT_IN_ep = -1;

_LIT(KUsbLddFilename, "eusbc");

_LIT(KOtgdiLddFilename, "otgdi");

_LIT(KUsbDeviceName, "Usbc");

// --- Local Constants

static const TInt KUsbDesc_SizeOffset = 0;

static const TInt KUsbDesc_TypeOffset = 1;

static const TInt KDevDesc_SpecOffset = 2;

static const TInt KDevDesc_DevClassOffset = 4;

static const TInt KDevDesc_DevSubClassOffset = 5;

static const TInt KDevDesc_DevProtocolOffset = 6;

static const TInt KDevDesc_Ep0SizeOffset = 7;

static const TInt KDevDesc_VendorIdOffset = 8;

static const TInt KDevDesc_ProductIdOffset = 10;

static const TInt KDevDesc_DevReleaseOffset = 12;

static const TInt KConfDesc_AttribOffset = 7;

static const TInt KConfDesc_MaxPowerOffset = 8;

static const TInt KIfcDesc_SettingOffset = 2;

static const TInt KIfcDesc_ProtocolOffset = 7;

static const TInt KEpDesc_PacketSizeOffset = 4;

static const TInt KEpDesc_IntervalOffset = 6;

static const TInt KEpDesc_SynchAddressOffset = 8;

//

// Helper.

//

static TEndpointState QueryEndpointState(TEndpointNumber aEndpoint)

	{

	TEndpointState ep_state = EEndpointStateUnknown;

	TInt r = gPort.EndpointStatus(aEndpoint, ep_state);

	test(r == KErrNone);

	test.Printf(_L("Endpoint %d state: %s\n"), aEndpoint,

				(ep_state == EEndpointStateNotStalled) ? _S("Not stalled") :

				((ep_state == EEndpointStateStalled) ? _S("Stalled") :

				 _S("Unknown...")));

	return ep_state;

	}

// --- Class CActiveKeypressNotifier

class CActiveKeypressNotifier : public CActive

	{

public:

	static CActiveKeypressNotifier* NewL(CConsoleBase* aConsole);

	~CActiveKeypressNotifier();

	void RequestCharacter();

	void ProcessKeyPressL(TChar aChar);

private:

	virtual void DoCancel();

	virtual void RunL();

	CActiveKeypressNotifier(CConsoleBase* aConsole);

	void ConstructL() {};

private:

	CConsoleBase* iConsole;

	};

CActiveKeypressNotifier* CActiveKeypressNotifier::NewL(CConsoleBase* aConsole)

	{

	CActiveKeypressNotifier* self = new (ELeave) CActiveKeypressNotifier(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop();

	return self;

	}

CActiveKeypressNotifier::CActiveKeypressNotifier(CConsoleBase* aConsole)

	: CActive(EPriorityNormal), iConsole(aConsole)

	{}

CActiveKeypressNotifier::~CActiveKeypressNotifier()

	{

	Cancel();												// base class cancel -> calls our DoCancel

	}

void CActiveKeypressNotifier::RunL()

	{

	gKeychar = (static_cast<TChar>(iConsole->KeyCode()));

	RequestCharacter();

	}

void CActiveKeypressNotifier::DoCancel()

	{

	iConsole->ReadCancel();

	}

void CActiveKeypressNotifier::RequestCharacter()

	{

	// A request is issued to the CConsoleBase to accept a character from the keyboard.

	if (IsActive())

		{

		return;

		}

	iConsole->Read(iStatus);

	SetActive();

	}

// --- Actual Test Functions

// 2nd Thread helper function

static TInt TestThreadFunction(TAny* aPtr)

	{

	RThread* other = static_cast<RThread*>(aPtr);

	RDevUsbcClient port = gPort;

	// Now try to duplicate the USB channel handle

	TInt r = port.Duplicate(*other);

 	// Wait for 1 second

 	User::After(1000000);

	return r;

	}

static void OpenChannel()

	{

	test.Start(_L("Open Channel"));

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

	TInt r = User::LoadLogicalDevice(KUsbLddFilename);

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

	RDevUsbcClient port1;

	test.Next(_L("Open local USB channel 1"));

	r = port1.Open(0);

	test(r == KErrNone);

	test.Next(_L("Open global USB channel"));

	r = gPort.Open(0);

	test(r == KErrNone);

	RDevUsbcClient port2;

	test.Next(_L("Open local USB channel 2"));

	r = port2.Open(0);

	test(r == KErrNone);

	test.Next(_L("Close USB channel 1"));

	port1.Close();

	RDevUsbcClient port3;

	test.Next(_L("Open local USB channel 3"));

	r = port3.Open(0);

	test(r == KErrNone);

	test.Next(_L("Close USB channel 2"));

	port2.Close();

	test.Next(_L("Close USB channel 3"));

	port3.Close();

	// Check for OTG support

	TBuf8<KUsbDescSize_Otg> otg_desc;

	r = gPort.GetOtgDescriptor(otg_desc);

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

	gSupportsOtg = (r != KErrNotSupported) ? ETrue : EFalse;

	// On an OTG device we have to start the OTG driver, otherwise the Client

	// stack will remain disabled forever.

	if (gSupportsOtg)

		{

		test.Printf(_L("Running on OTG device: loading OTG driver\n"));

		test.Next(_L("Load OTG LDD"));

		r = User::LoadLogicalDevice(KOtgdiLddFilename);

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

		test.Next(_L("Open OTG channel"));

		r = gOTG.Open();

		test(r == KErrNone);

		test.Next(_L("Start OTG stack"));

		r = gOTG.StartStacks();

		test(r == KErrNone);

		}

	// Try duplicating channel handle in a second thread

	// (which should not work because we don't support it)

	test.Next(_L("Create 2nd Thread"));

	RThread me;

 	TThreadId me_id = me.Id();

	// We need to open the RThread object, otherwise we'll only get the

	// 'special' handle 0xFFFF8001.

	test(me.Open(me_id) == KErrNone);

	RThread test_thread;

	TBuf<17> name = _L("tusbapitestthread");

	test(test_thread.Create(name, TestThreadFunction, 0x1000, NULL, &me) == KErrNone);

	test.Next(_L("Logon to 2nd Thread"));

	TRequestStatus stat;

	test_thread.Logon(stat);

	test(stat == KRequestPending);

	test_thread.Resume();

	test.Next(_L("Wait for 2nd Thread to exit"));

	User::WaitForRequest(stat);

	// Check correct return value of RDevUsbcClient::Duplicate()

	test(stat == KErrAccessDenied);

	test.Next(_L("Close 2nd Thread"));

	test_thread.Close();

	test.End();

	}

static void TestResourceAllocationV1()

	{

	test.Start(_L("Test Endpoint Resource Allocation"));

	test.Next(_L("Request DMA resource"));

	const TInt dma = gPort.AllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDMA);

	TBool res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDMA);

	test.Printf(_L("DMA on endpoint 1 %s\n"),

				res ? _S("now allocated") : _S("not allocated"));

	if (dma == KErrNone)

		// Only if DMA resource was successfully allocated should we expect truth here:

		test(res);

	else

		test(!res);

	test.Next(_L("Request Double Buffering resource"));

	const TInt db = gPort.AllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

	test.Printf(_L("Double Buffering on endpoint 1 %s\n"),

				res ? _S("now allocated") : _S("not allocated"));

	if (db == KErrNone)

		// Only if DB resource was successfully allocated should we expect truth here:

		test(res);

	else

		test(!res);

	test.Next(_L("Deallocate Double Buffering resource"));

	TInt r = gPort.DeAllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

	// Whether DB is dynamic or permanent - deallocation (if supported) should always return success:

	if (db == KErrNone)

		test(r == KErrNone);

	else

		test(r != KErrNone);

	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

	test.Printf(_L("Double Buffering on endpoint 1 %s\n"),

				res ? _S("still allocated") : _S("not (longer) allocated"));

	test.Next(_L("Deallocate DMA resource"));

	r = gPort.DeAllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDMA);

	// Whether DMA is dynamic or permanent - deallocation (if supported) should always return success:

	if (dma == KErrNone)

		test(r == KErrNone);

	else

		test(r != KErrNone);

	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDMA);

	test.Printf(_L("DMA on endpoint 1 %s\n"),

				res ? _S("still allocated") : _S("not (longer) allocated"));

	test.End();

	}

static void SetupInterface()

	{

	test.Start(_L("Query USB device caps and set up interface"));

	// Device caps

	test.Next(_L("Query USB device caps"));

	TUsbDeviceCaps d_caps;

	TInt r = gPort.DeviceCaps(d_caps);

	test(r == KErrNone);

	TInt n = d_caps().iTotalEndpoints;

	// Global variable - we'll need this value later

	gSupportsHighSpeed = d_caps().iHighSpeed;

	gSupportResouceAllocationV2 = (d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2);

	test.Printf(_L("### USB device capabilities:\n"));

	test.Printf(_L("Number of endpoints:                        %d\n"), n);

	test.Printf(_L("Supports Software-Connect:                  %s\n"),

				d_caps().iConnect ? _S("yes") : _S("no"));

	test.Printf(_L("Device is Self-Powered:                     %s\n"),

				d_caps().iSelfPowered ? _S("yes") : _S("no"));

	test.Printf(_L("Supports Remote-Wakeup:                     %s\n"),

				d_caps().iRemoteWakeup ? _S("yes") : _S("no"));

	test.Printf(_L("Supports High-speed:                        %s\n"),

				gSupportsHighSpeed ? _S("yes") : _S("no"));

	test.Printf(_L("Supports OTG:                               %s\n"),

				gSupportsOtg ? _S("yes") : _S("no"));

	test.Printf(_L("Supports unpowered cable detection:         %s\n"),

				(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ?

				_S("yes") : _S("no"));

	test.Printf(_L("Supports endpoint resource alloc scheme V2: %s\n"),

				gSupportResouceAllocationV2 ? _S("yes") : _S("no"));

	test(n >= 2);

	test.Printf(_L("(Device has sufficient endpoints.)\n"));

	// Endpoint caps

	test.Next(_L("Query USB endpoint caps"));

	TUsbcEndpointData data[KUsbcMaxEndpoints];

	TPtr8 dataptr(reinterpret_cast<TUint8*>(data), sizeof(data), sizeof(data));

	r = gPort.EndpointCaps(dataptr);

	test(r == KErrNone);

	test.Printf(_L("### USB device endpoint capabilities:\n"));

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

		{

		const TUsbcEndpointCaps* caps = &data[i].iCaps;

		test.Printf(_L("Endpoint: SizeMask = 0x%08x TypeDirMask = 0x%08x\n"),

					caps->iSizes, caps->iTypesAndDir);

		if (caps->iHighBandwidth)

			{

			test.Printf(_L("  (high-speed, high bandwidth endpoint)\n"));

			// Must be HS Int or Iso ep

			test(gSupportsHighSpeed);

			test(caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpTypeInterrupt));

			}

		}

	test.Next(_L("Looking for suitable endpoints"));

	// Set the active interface

	TUsbcInterfaceInfoBuf ifc;

	TInt ep_found = 0;

	TBool foundBulkIN = EFalse;

	TBool foundBulkOUT = EFalse;

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

		{

		const TUsbcEndpointCaps* caps = &data[i].iCaps;

		const TInt mps = caps->MaxPacketSize();

		if (!foundBulkIN &&

			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirIn)) ==

			(KUsbEpTypeBulk | KUsbEpDirIn))

			{

			// EEndpoint1 is going to be our TX (IN, write) endpoint

			ifc().iEndpointData[0].iType = KUsbEpTypeBulk;

			ifc().iEndpointData[0].iDir  = KUsbEpDirIn;

			ifc().iEndpointData[0].iSize = mps;

			foundBulkIN = ETrue;

			if (++ep_found == 2)

				break;

			}

		else if (!foundBulkOUT &&

			(caps->iTypesAndDir & (KUsbEpTypeBulk | KUsbEpDirOut)) ==

				 (KUsbEpTypeBulk | KUsbEpDirOut))

			{

			// EEndpoint2 is going to be our RX (OUT, read) endpoint

			ifc().iEndpointData[1].iType = KUsbEpTypeBulk;

			ifc().iEndpointData[1].iDir  = KUsbEpDirOut;

			ifc().iEndpointData[1].iSize = mps;

			foundBulkOUT = ETrue;

			if (++ep_found == 2)

				break;

			}

		}

	test(ep_found == 2);

	test.Next(_L("Setting up main interface"));

	_LIT16(string, "T_USBAPI Test Interface (Setting 0)");

	ifc().iString = const_cast<TDesC16*>(&string);

	ifc().iTotalEndpointsUsed = 2;

	ifc().iClass.iClassNum	  = 0xff;

	ifc().iClass.iSubClassNum = 0xff;

	ifc().iClass.iProtocolNum = 0xff;

	// Set up the interface.

	r = gPort.SetInterface(0, ifc);

	test(r == KErrNone);

	TInt ifc_no = -1;

	r = gPort.GetAlternateSetting(ifc_no);

	test(r == KErrUsbDeviceNotConfigured);

	// Some UDCs won't allow endpoint resource manipulation once the hardware has been

	// configured and turned on. So we do it here & now:

	if (!gSupportResouceAllocationV2)

		{

		TestResourceAllocationV1();

		}

	// On the other hand, since some UDCs won't let us test many features which require

	// register access until the USB hardware is powered up (and because it might start

	// out unpowered), we should turn it on here explicitly.

	// (It will be turned off automatically by the PIL after all tests have been run,

	// when the interface gets deleted.)

	test.Next(_L("Powering up UDC (1)"));

	r = gPort.PowerUpUdc();

	if (!gSupportsOtg)

		{

		test(r == KErrNone);

		}

	else

		{

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

		}

	if (gSupportsOtg && (r == KErrNotReady))

		{

		test.Printf(_L("OTG device but not connected to Host, stopping subtest here.\n"));

		test.End();

		return;

		}

	// The board might be attached to a PC with HS controller, thus enabling us

	// to test some HS-specific features. For that to work we have to connect

	// the board to the PC. The "Found new device" box that may pop up on the PC

	// in response to this can be ignored (i.e. just closed).

	test.Next(_L("Connecting to Host (1)"));

	r = gPort.DeviceConnectToHost();