// Copyright (c) 2000-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:

// e32test/device/t_usbco2.cpp

// USB Test Program T_USB, functional part.

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

// 

//

#include <e32hal.h>

#include <e32uid.h>

#include <hal.h>

#include "t_usb.h"											// CActiveConsole, CActiveRW

#include "t_usblib.h"										// Helpers

_LIT(KUsbLddFilename, "eusbc");								// .ldd assumed - it's a filename

_LIT(KOtgdiLddFilename, "otgdi");

_LIT(KUsbDeviceName, "Usbc");

_LIT(KFileName, "\\T_USBFILE.BIN");

_LIT(KActivePanic, "T_USB");

static const TUint32 KTusbVersion = 20070524;				// just an edit date really

static const TUint8 KUsbrflctVersionMajor = 1;				// the version we're compatible with

static const TUint8 KUsbrflctVersionMinor = 5;

static const TUint8 KUsbrflctVersionMicro = 0;

static const TInt KMaxFileSize = 100 * 1024 * 1024;			// 100MB (requires at least 128MB card)

static const TInt KInitialBufSz = 0;

static const TInt stridx1 = 0xCC;

static const TInt stridx2 = 0xEE;

//

// --- class CActiveConsole ---------------------------------------------------------

//

CActiveConsole::CActiveConsole(CConsoleBase* aConsole, TBool aVerboseOutput)

	: CActive(EPriorityNormal),

	  iConsole(aConsole),

	  iRW(NULL),

	  iBufferSizeChosen(EFalse),

	  iBandwidthPriorityChosen(EFalse),

	  iDMAChosen(EFalse),

	  iDoubleBufferingChosen(EFalse),

	  iSoftwareConnect(EFalse),

	  iHighSpeed(EFalse),

	  iOtg(EFalse),

	  iVerbose(aVerboseOutput)

	{}

CActiveConsole* CActiveConsole::NewLC(CConsoleBase* aConsole, TBool aVerboseOutput)

	{

	CActiveConsole* self = new (ELeave) CActiveConsole(aConsole, aVerboseOutput);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CActiveConsole* CActiveConsole::NewL(CConsoleBase* aConsole, TBool aVerboseOutput)

	{

	CActiveConsole* self = NewLC(aConsole, aVerboseOutput);

	CleanupStack::Pop();

	return self;

	}

void CActiveConsole::ConstructL()

	{

	CActiveScheduler::Add(this);

	// 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.)

	TInt r = User::LoadLogicalDevice(KUsbLddFilename);

	if (r != KErrNone && r != KErrAlreadyExists)

		{

		TUSB_PRINT1("Error %d on loading USB LDD", r);

		User::Leave(-1);

		return;

		}

	TUSB_PRINT("Successfully loaded USB LDD");

	// Open USB channel

	r = iPort.Open(0);

	if (r != KErrNone)

		{

		TUSB_PRINT1("Error %d on opening USB port", r);

		User::Leave(-1);

		return;

		}

	TUSB_PRINT("Successfully opened USB port");

	// Create Reader/Writer active object

	iRW = CActiveRW::NewL(iConsole, &iPort, iVerbose);

	if (!iRW)

		{

		TUSB_PRINT("Failed to create reader/writer");

		User::Leave(-1);

		return;

		}

	TUSB_PRINT("Created reader/writer");

	// Check for OTG support

	TBuf8<KUsbDescSize_Otg> otg_desc;

	r = iPort.GetOtgDescriptor(otg_desc);

	if (!(r == KErrNotSupported || r == KErrNone))

		{

		TUSB_PRINT1("Error %d while fetching OTG descriptor", r);

		User::Leave(-1);

		return;

		}

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

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

	// stack will remain disabled forever.

	if (iOtg)

		{

		TUSB_PRINT("Running on OTG device: loading OTG driver");

		r = User::LoadLogicalDevice(KOtgdiLddFilename);

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error %d on loading OTG LDD", r);

			User::Leave(-1);

			return;

			}

		r = iOtgPort.Open();

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error %d on opening OTG port", r);

			User::Leave(-1);

			return;

			}

		r = iOtgPort.StartStacks();

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error %d on starting USB stack", r);

			User::Leave(-1);

			return;

			}

		}

	}

TInt CActiveConsole::SetupInterface()

	{

	// Query the USB device/Setup the USB interface

	TInt r = QueryUsbClientL();

	if (r != KErrNone)

		{

		TUSB_PRINT1("Interface setup failed", r);

		return r;

		}

	TUSB_PRINT("Interface successfully set up");

	// Change some descriptors to contain suitable values

	r = SetupDescriptors();

	if (r != KErrNone)

		{

		TUSB_PRINT1("Descriptor setup failed", r);

		return r;

		}

	// Create device state active object

	iDeviceStateNotifier = CActiveDeviceStateNotifier::NewL(iConsole, &iPort, iVerbose);

	if (!iDeviceStateNotifier)

		{

		TUSB_PRINT("Failed to create device state notifier");

		return r;

		}

	iDeviceStateNotifier->Activate();

	// Create endpoint stall status active object

	iStallNotifier = CActiveStallNotifier::NewL(iConsole, &iPort, iVerbose);

	if (!iStallNotifier)

		{

		TUSB_PRINT("Failed to create stall notifier");

		return r;

		}

	iStallNotifier->Activate();

	return r;

	}

CActiveConsole::~CActiveConsole()

	{

	TUSB_VERBOSE_PRINT("CActiveConsole::~CActiveConsole()");

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

	delete iRW;												// destroy the reader/writer

	delete iDeviceStateNotifier;

	delete iStallNotifier;

	TInt r = iPort.RemoveStringDescriptor(stridx1);

	if (r != KErrNone)

		{

		TUSB_PRINT1("Error %d on string removal", r);

		}

	r = iPort.RemoveStringDescriptor(stridx2);

	if (r != KErrNone)

		{

		TUSB_PRINT1("Error %d on string removal", r);

		}

	if (iOtg)

		{

		TUSB_PRINT("Running on OTG device: unloading OTG driver");

		iOtgPort.StopStacks();

		iOtgPort.Close();

		r = User::FreeLogicalDevice(RUsbOtgDriver::Name());

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error %d on freeing OTG LDD", r);

			}

		}

	iPort.Close();											// close USB channel

	r = User::FreeLogicalDevice(KUsbDeviceName);

	if (r != KErrNone)

		{

		TUSB_PRINT1("Error %d during unloading USB LDD", r);

		User::Leave(-1);

		return;

		}

	TUSB_PRINT("Successfully unloaded USB LDD");	

	}

void CActiveConsole::DoCancel()

	{

	TUSB_VERBOSE_PRINT("CActiveConsole::DoCancel()");

	iConsole->ReadCancel();

	}

void CActiveConsole::RunL()

	{

	TUSB_VERBOSE_PRINT("CActiveConsole::RunL()");

	ProcessKeyPressL(static_cast<TChar>(iConsole->KeyCode()));

	}

void CActiveConsole::RequestCharacter()

	{

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

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KActivePanic, 666));

	if (!iBufferSizeChosen)

		{

		iConsole->Printf(_L("\n"));

		iConsole->Printf(_L("++++ Choose max. Transfer Size ++++\n"));

		iConsole->Printf(_L("  '0' - Set up USB device for USBCV\n"));

		iConsole->Printf(_L("  '1' -   32 bytes\n"));

		iConsole->Printf(_L("  '2' - 1024 bytes\n"));

		iConsole->Printf(_L("  '3' -   64 kbytes\n"));

		iConsole->Printf(_L("  '4' -    1 Mbyte\n"));

		}

	else if (!iBandwidthPriorityChosen)

		{

		iConsole->Printf(_L("\n"));

		iConsole->Printf(_L("++++ Choose Bandwidth Priority ++++\n"));

		iConsole->Printf(_L("  '1' - Economical buffering - default\n"));

		iConsole->Printf(_L("  '2' - More memory than default buffering - Plus1\n"));

		iConsole->Printf(_L("  '3' - More memory than Plus1 buffering - Plus2\n"));

		iConsole->Printf(_L("  '4' - Maximum buffering\n"));

		}

	else if (!iDMAChosen)

		{

		iConsole->Printf(_L("\n"));

		iConsole->Printf(_L("++++ Choose Endpoint I/O Transfer Mode ++++\n"));

		iConsole->Printf(_L("  '1' - Interrupt Mode\n"));

		iConsole->Printf(_L("  '2' - DMA Mode (recommended)\n"));

		}

	else if (!iDoubleBufferingChosen)

		{

		iConsole->Printf(_L("\n"));

		iConsole->Printf(_L("++++ Choose Endpoint FIFO Mode ++++\n"));

		iConsole->Printf(_L("  '1' - Normal Buffering Mode\n"));

		iConsole->Printf(_L("  '2' - Double Buffering Mode (recommended)\n"));

		}

	else

		{

		iConsole->Printf(_L("\n"));

		iConsole->Printf(_L("++++ Select Program Option ++++\n"));

		iConsole->Printf(_L("  'L'oop test\n"));

		iConsole->Printf(_L("   Loop test with data 'C'ompare\n"));

		iConsole->Printf(_L("  'R'eceive-only test (we receive, host transmits)\n"));

		iConsole->Printf(_L("  'T'ransmit-only test\n"));

		iConsole->Printf(_L("   Receive and 'P'ut (write) to File\n"));

		iConsole->Printf(_L("   Transmit and 'G'et (read) from File\n"));

		iConsole->Printf(_L("   Signal Remote-'W'akeup to the host\n"));

		iConsole->Printf(_L("  'S'top current transfer\n"));

#ifdef WITH_DUMP_OPTION

		iConsole->Printf(_L("  'D'ump USB regs to debugout\n"));

#endif

		iConsole->Printf(_L("   Re'E'numerate device\n"));

		iConsole->Printf(_L("  'Q'uit this app\n"));

		}

	iConsole->Read(iStatus);

	SetActive();

	}

void CActiveConsole::ProcessKeyPressL(TChar aChar)

	{

	if (aChar == EKeyEscape)

		{

		RDebug::Print(_L("CActiveConsole: ESC key pressed -> stopping active scheduler..."));

		CActiveScheduler::Stop();

		return;

		}

	if (!iBufferSizeChosen)

		{

		// Set maximum buffer size from keypress

		switch (aChar)

			{

		case '0':

			// This is for creating a USB device that just enumerates,

			// to be used for compliance testing with USBCV.

			iRW->SetMaxBufSize(0);

			break;

		case '1':

			iRW->SetMaxBufSize(32);

			break;

		case '2':

			iRW->SetMaxBufSize(1024);

			break;

		case '3':

			iRW->SetMaxBufSize(64 * 1024);

			break;

		case '4':

			iRW->SetMaxBufSize(KMaxBufSize);

			break;

		default:

			TUSB_PRINT1("Not a valid input character: %c", aChar.operator TUint());

			goto request_char;

			}

		TUSB_PRINT1("Maximum buffer size set to %d bytes", iRW->MaxBufSize());

		iBufferSizeChosen = ETrue;

		}

	else if (!iBandwidthPriorityChosen)

		{

		// Set bandwidth priority from keypress

		switch (aChar)

			{

		case '1':

			iBandwidthPriority = EUsbcBandwidthOUTDefault | EUsbcBandwidthINDefault;

			TUSB_PRINT("Bandwith priority set to default");

			break;

		case '2':

			iBandwidthPriority = EUsbcBandwidthOUTPlus1 | EUsbcBandwidthINPlus1;

			TUSB_PRINT("Bandwith priority set to Plus1");

			break;

		case '3':

			iBandwidthPriority = EUsbcBandwidthOUTPlus2 | EUsbcBandwidthINPlus2;

			TUSB_PRINT("Bandwith priority set to Plus2");

			break;

		case '4':

			iBandwidthPriority = EUsbcBandwidthINMaximum | EUsbcBandwidthOUTMaximum;

			TUSB_PRINT("Bandwith priority set to maximum");

			break;

		default:

			TUSB_PRINT1("Not a valid input character: %c", aChar.operator TUint());

			goto request_char;

			}

		TUSB_PRINT1("(Set to 0x%08X)", iBandwidthPriority);

		iBandwidthPriorityChosen = ETrue;

		TUSB_PRINT("Configuring interface...");

		TInt r = SetupInterface();

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error: %d. Stopping active scheduler...", r);

			CActiveScheduler::Stop();

			return;

			}

		}

	else if (!iDMAChosen)

		{

		// Set DMA mode from keypress

		switch (aChar)

			{

		case '1':

			TUSB_PRINT("- Trying to deallocate endpoint DMA:\n");

			DeAllocateEndpointDMA(EEndpoint1);

			DeAllocateEndpointDMA(EEndpoint2);

			break;

		case '2':

			TUSB_PRINT("- Trying to allocate endpoint DMA:\n");

			AllocateEndpointDMA(EEndpoint1);

			AllocateEndpointDMA(EEndpoint2);

			break;

		default:

			TUSB_PRINT1("Not a valid input character: %c", aChar.operator TUint());

			goto request_char;

			}

		iDMAChosen = ETrue;

		}

	else if (!iDoubleBufferingChosen)

		{

		// Set Double Buffering from keypress

		switch (aChar)

			{

		case '1':

			TUSB_PRINT("- Trying to deallocate Double Buffering:\n");

			DeAllocateDoubleBuffering(EEndpoint1);

			DeAllocateDoubleBuffering(EEndpoint2);

			break;

		case '2':

			TUSB_PRINT("- Trying to allocate Double Buffering:\n");

			AllocateDoubleBuffering(EEndpoint1);

			AllocateDoubleBuffering(EEndpoint2);

			break;

		default:

			TUSB_PRINT1("Not a valid input character: %c", aChar.operator TUint());

			goto request_char;

			}

		iDoubleBufferingChosen = ETrue;

		// Everything chosen, so let's re-enumerate...

		TUSB_PRINT("Enumeration...");

		TInt r = ReEnumerate();

		if (r != KErrNone)

			{

			TUSB_PRINT1("Error: %d. Stopping active scheduler...", r);

			CActiveScheduler::Stop();

			return;

			}

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

		// Make sure program versions match if testing against USBRFLCT

		if (iRW->MaxBufSize() != 0)

			{

			r = iRW->ExchangeVersions();

			if (r != KErrNone)

				{

				TUSB_PRINT1("Error: %d. Stopping active scheduler...", r);

				CActiveScheduler::Stop();

				return;

				}

			}

		}

	else

		{

		// Execute one of the 'proper' program functions

		switch (aChar)

			{

		case 'l':					// start loop test

		case 'L':

			TUSB_PRINT("-> Loop test selected\n");

			iRW->SetTransferMode(ELoop);

			iRW->SendPreamble();

			break;

		case 'c':					// start loop/compare test

		case 'C':

			TUSB_PRINT("-> Loop test with compare selected\n");

			iRW->SetTransferMode(ELoopComp);

			iRW->SendPreamble();

			break;

		case 'r':					// start receive-only test

		case 'R':

			TUSB_PRINT("-> Receive-only test selected\n");

			iRW->SetTransferMode(EReceiveOnly);

			iRW->SendPreamble();

			break;

		case 't':					// start transmit-only test

		case 'T':

			TUSB_PRINT("-> Transmit-only test selected\n");

			iRW->SetTransferMode(ETransmitOnly);

			iRW->SendPreamble();

			break;

		case 'g':					// start transmit & get-from-file test

		case 'G':

			TUSB_PRINT("-> Transmit from file test selected\n");

			iRW->SetTransferMode(ETransmitOnly);

			iRW->ReadFromDisk(ETrue);

			iRW->SendPreamble();

			break;

		case 'p':					// start receive & put-to-file test

		case 'P':

			TUSB_PRINT("-> Receive to file test selected\n");

			iRW->SetTransferMode(EReceiveOnly);

			iRW->WriteToDisk(ETrue);

			iRW->SendPreamble();

			break;

		case 'w':					// remote-wakeup

		case 'W':

			TUSB_PRINT("-> Signal Remote-wakeup selected\n");

			iPort.SignalRemoteWakeup();

			break;

		case 's':					// stop either

		case 'S':

			TUSB_PRINT("-> Stop transfer selected\n");

			iRW->Stop();

			break;

#ifdef WITH_DUMP_OPTION

		case 'd':					// dump controller registers

		case 'D':

			TUSB_PRINT("-> Dump option selected\n");

			iPort.DumpRegisters();

			QueryRxBuffer();

			break;

#endif

		case 'e':					// ReEnumerate()

		case 'E':

			TUSB_PRINT("-> Re-enumerate device selected\n");

			ReEnumerate();

			break;

		case 'q':					// quit

		case 'Q':

			TUSB_PRINT("-> Quit program selected\n");

			TUSB_VERBOSE_PRINT("CActiveConsole: stopping active scheduler...");

			CActiveScheduler::Stop();

			return;

		default:

			TUSB_PRINT1("-> Not a valid input character: %c", aChar.operator TUint());

			goto request_char;

			}

		}

 request_char: