// Copyright (c) 2007-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_usbcsc.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32def.h>

#include <e32def_private.h>

#include <d32usbcsc.h>

#include <hal.h>

#include "t_usblib.h"

#include <e32svr.h>

#include "u32std.h"

//#define DEBUGVERSION

#ifdef DEBUGVERSION

#define DEBUGPRINT(a) {a;}

#else

#define DEBUGPRINT(a) {}

#endif

LOCAL_D RTest test(_L("T_USBCSC"));

_LIT(KLddName, "eusbcsc");

_LIT(KUsbDeviceName, "Usbcsc");

static char sym[9]="`*+@$#%!";

// Constants to be used in Descriptor Tests

static const TInt KUsbDesc_SizeOffset = 0;		//for SetCS EndpointDescriptor

static const TInt KUsbDesc_TypeOffset = 1;		//for SetCS EndpointDescriptor

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;

//

const TInt KUsbcMaxBuffers = 32; // Maximum buffers per device (15 In + 15 Out + 2 for Ep0)

const TInt KUsbcMaxAltSetting = 5; // Maximum alternate setting an interface can have  

static RDevUsbcScClient gPort;

// Values to be found from device capabilities

static TBool gSupportsHighSpeed;

TInt gInterruptInEpFound = 0;

//Command Line parameters 

TBool gRealHardware = EFalse;

TInt gVerbose = 0;

enum TSpecTestType {EAll=0,EBufRead,EBufWrite,EEp0, EAltSet, EInterface, ECancel, EInvalidApi, EDescriptor, /*insert new non-bil here*/ EBilRw=100, EBilEp0, EBilAlt};

TSpecTestType gSpecTest = EAll;

RChunk gChunk;

static const TInt gBytesReceived = 128;

static const TInt KMaxBufSize = 1024 * 1024;				// max data buffer size: 1MB

// Masks for EP0Setup type. (Used By BIL tests and LDD tests)

const TUint KDeviceToHost   = 0x80;

//const TUint KDirMask		= 0x80;

const TUint KDirBit			= 0x7;

//const TUint KReqTypeMask	= 0x60;

const TUint KReqTypeBit		= 0x5;

const TUint KRecepientMask	= 0x1F;

const TUint KRecepientReservedMask	= 0x1C;

//Forward Declaration

class TAlternateSetting;

class CActiveRW;

class TBuffer;

class TEndpointWrapper;

// Stucture which holds how many in and out endpoints an alternate setting in the chunk should contain

struct TEndpointDescription

	{

	TInt iNumOfEp;

	TInt iNumOfOutEp;

	TInt iNumOfInEp;

	};

// This class is used for checking against the contents of the chunk after its construction

class TAltSetConfig

	{

public:

	TInt iNumOfAltSet; 

	TEndpointDescription iEpsDesc[KMaxEndpointsPerClient];

	};

enum Tep0phase {EReady, EDataIn};

struct Sep0SetupPacket

	{

	TUint8 iRequestType;

	TUint8 iRequest;

	TUint16 iwValue;

	TUint16 iwIndex;

	TUint16 iWlength;

	};

// CActive class to monitor KeyStrokes from User (Only EKeyEscape in this test)

class CActiveConsole : public CActive

	{

public:

	CActiveConsole();

	~CActiveConsole();

	void GetCharacter();

private:

	// Defined as pure virtual by CActive;

	// implementation provided by this class.

	virtual void DoCancel();

	// Defined as pure virtual by CActive;

	// implementation provided by this class,

	virtual void RunL();

	};

//CActive class to monitor Device/AlternateSetting changes

class CActiveDeviceStateNotifier : public CActive

	{

public:

	CActiveDeviceStateNotifier();

	~CActiveDeviceStateNotifier();

	void Activate();

private:

	virtual void DoCancel();

	virtual void RunL();

private:

	TUint iDeviceState;

	};

class CActiveStallNotifier : public CActive

	{

public:

	CActiveStallNotifier();

	~CActiveStallNotifier();

	void Activate();

private:

	virtual void DoCancel();

	virtual void RunL();

private:

	TUint iEndpointState;

	};

//Class containing all alternate settings

class TInterface

	{

public:

	TInterface();

	~TInterface();

	void AddAlternateSetting(TAlternateSetting &aAlternateSetting);

	void SetActiveAlternateSetting(TInt aSettingNum, TBool aStartNextInAltSet = EFalse);

	TInt GetAltSettingChangeSequenceNum();

private:

	void IncrementAltSettingChangeSequenceNum();

private:

	TInt iAltSettingChangeSequenceNum; // To keep track of alternate setting changes, Always is one more than previous after an alternat setting change.

	RArray <TAlternateSetting> iAlternateSetting;

	};

//Class containing all endpoints of an alternate setting 

class TAlternateSetting

	{

public:

	TAlternateSetting(TInt aAltSetNum);

	~TAlternateSetting();

	void AddEndpoint(CActiveRW &aEp); 

	void SetInterfaceHandle(TInterface *aInterface);

	TInt GetAlternateSetting();

	TInt GetInterfaceAltSettingChangeSequenceNum();

	void Activate(TBool aStartNextInAltSet = EFalse);

	void SetChangeRequestFlag(CActiveRW *aEp);

	TBool CheckFlagForAllOutEndpoints();

	void ChangeAlternateSetting(TInt aAltsetting);

private:

	TInt iAltSetNum;

	TInterface *iInterface;

	RArray <TEndpointWrapper> iEndpoints;

	};

// CActive class represents an endpoint for reading or writing 

class CActiveRW : public CActive

	{

public:

	CActiveRW(TInt aEndpointNum, TInt aDirection, TBuffer* aBuffer);

	~CActiveRW();

	void SetAlternateSettingHandle(TAlternateSetting *aAlternateSetting);	

	TInt GetAlternateSettingOfEndpoint();

	TBool CheckFlagForAllOutEndpoints();

	TInt GetInterfaceAltSettingChangeSequenceNum();

	void CallChangeAlternateSetting(TInt aAltsetting);

	TInt GetEndpointNumber();

	TInt GetDirection();

	void QueueRequests();	

	TInt StartRead();

	void StartWrite();

	void SetChangeRequestFlag(TBuffer *aBuffer);

private:

	virtual void RunL();

	virtual void DoCancel();

private:

	TInt iLogicalEndpointNum;	

	TInt iDirection;

	TAlternateSetting* iAltSetting;

public:

	TBuffer* iBuffer; 

	};

class TBuffer

	{

public:

	TBuffer(TInt aBufNum);

	~TBuffer();

	void SetEndpointHandle(CActiveRW* aEndpoint);	

	void SetUpHeader(); 

	void ProcessData();	

	void SendEP0Packet(TInt aLength);

public:

	CActiveRW* iEndpoint; // To know which endpoint of an alternate setting it belongs to 

	TInt iBufNum;

	TBool iIsHeaderSetUp;	// If already setUp 

	//For Ep0

	Sep0SetupPacket* iSetup;	

	Tep0phase iEp0Phase;	

	//For Reading	

	TUsbcScTransferHeader* iTransfer;

	SUsbcScBufferHeader* iHeader;

	TUint iMaxBufferSize;

	TUint iMaxPacketSize;

	TUint iBase;

	TInt iOldTail; 

#if _DEBUG

	TUint iPrevSequence;

	TUint iLoop;

#endif

	TInt iBytesReceived;

	TInt iTickCount;

	TUint iPrevAltSeq;

	//For Writing

	TUint iBufferOffset;

	TUint iLength;

	};

class TEndpointWrapper

	{

public:

	CActiveRW*	iEp;

	TBool iSettingChangeReceived; // Flag to check if "empty packet" containing alternate setting change is received

	};

/* Open drivers, with a few endpoints. Check each endpoint has headers that

   make sense.  Getting the test program to this stage will be an

   achievement in itself! */

void TestBufferConstruction(TAltSetConfig* aAltSetConfig)

	{

	TInt r;

	test.Next(_L("Buffer Construction"));

	r = gPort.RealizeInterface(gChunk);

	test_KErrNone(r);

	TUsbcScChunkHeader chunkHeader(gChunk);

	DEBUGPRINT(test.Printf(_L("iBuffers at 0x%x, iAltSettings at 0x%x\n"),chunkHeader.iBuffers, chunkHeader.iAltSettings));

	test_Equal(gChunk.Base()+ sizeof(TUint)*2, chunkHeader.iBuffers);

	DEBUGPRINT(test.Printf(_L("iBuffers: EP0Out: 0x%x EP0In: 0x%x\n"), chunkHeader.iBuffers->Ep0Out()->Offset(),  

																	chunkHeader.iBuffers->Ep0In()->Offset()));

	DEBUGPRINT(test.Printf(_L("iAltSettings: Number of: %d First offset: 0x%x \n"), chunkHeader.iAltSettings->iNumOfAltSettings,  

																	chunkHeader.iAltSettings->iAltTableOffset[0]));

	test_Compare(aAltSetConfig->iNumOfAltSet, ==, chunkHeader.iAltSettings->iNumOfAltSettings);

	TInt maxInEps = 0, maxOutEps = 0;

	for (int i = 0; i < chunkHeader.iAltSettings->iNumOfAltSettings; i++)

		{

		TInt inEps = 0, outEps = 0;

		DEBUGPRINT(test.Printf(_L("Alternate Setting %d offset: 0x%x \n"), i, chunkHeader.iAltSettings->iAltTableOffset[i]));

		TInt8* endpoint = (TInt8*) (chunkHeader.iAltSettings->iAltTableOffset[i] + (TInt) gChunk.Base());

		for (int j = 1; j <= chunkHeader.GetNumberOfEndpoints(i); j++)

			{

			TUsbcScHdrEndpointRecord* endpointInf = (TUsbcScHdrEndpointRecord*) &(endpoint[j * chunkHeader.iAltSettings->iEpRecordSize]);

			DEBUGPRINT(test.Printf(_L("Endpoint %d owns buffer %d BufferOffset 0x%x Dir %d Type %d\n"), j, endpointInf->iBufferNo, chunkHeader.iBuffers->Buffers(endpointInf->iBufferNo)->Offset(), 

						endpointInf->Direction(), endpointInf->Type()));

			if (endpointInf->Direction() == KUsbScHdrEpDirectionOut)

				{

				outEps++;

				}

			else 

				{

				inEps++;

				}

			}

		DEBUGPRINT(test.Printf(_L("Test if Alternate Setting %d  has %d endpoints (%d Out Endpoint(s) and %d In Endpoint(s)) \n"), i, aAltSetConfig->iEpsDesc[i].iNumOfEp,

				aAltSetConfig->iEpsDesc[i].iNumOfOutEp, aAltSetConfig->iEpsDesc[i].iNumOfInEp));

		test_Compare(chunkHeader.GetNumberOfEndpoints(i), ==, aAltSetConfig->iEpsDesc[i].iNumOfEp);

		test_Compare(outEps, ==, aAltSetConfig->iEpsDesc[i].iNumOfOutEp);

		test_Compare(inEps, ==, aAltSetConfig->iEpsDesc[i].iNumOfInEp);

		if (outEps > maxOutEps)

			maxOutEps = outEps;

		if (inEps > maxInEps)

			maxInEps = inEps;

		}

	test_Compare(chunkHeader.iBuffers->NumberOfBuffers(), ==, (maxOutEps + maxInEps));

	}

// Function Definitions *****

TInt WaitUntilTimeout(TInt aTimout, TRequestStatus& aStatus)

{

	TRequestStatus timerStatus;

	RTimer timer;

	test_KErrNone(timer.CreateLocal());

	timer.After(timerStatus,aTimout*1000);

	User::WaitForRequest(timerStatus, aStatus);

	return (timerStatus.Int()!=KRequestPending)?KErrTimedOut:KErrNone;

}

// Class CActiveConsole

CActiveConsole::CActiveConsole()

	: CActive(EPriorityHigh)

	{

	CActiveScheduler::Add(this);

	}

CActiveConsole::~CActiveConsole()

	{

	Cancel();

	}

void CActiveConsole::GetCharacter()

	{

	test.Printf(_L("\n \n ***** Press Escape to exit ***** \n \n"));

	test.Console()->Read(iStatus);

	SetActive();

	}

void CActiveConsole::DoCancel()

	{

	DEBUGPRINT(test.Printf(_L("CActiveConsole::DoCancel\n")));

	test.Console()->ReadCancel();

	}

void CActiveConsole::RunL()

	{

	DEBUGPRINT(test.Printf(_L("\n CActiveConsole::RunL\n")));

	if (test.Console()->KeyCode() == EKeyEscape)

		{

		test.Printf(_L("CActiveConsole: ESC key pressed -> stopping active scheduler...\n"));

		CActiveScheduler::Stop();

		return;

		}

	GetCharacter();

	}

// Class CActiveDeviceStateNotifier

CActiveDeviceStateNotifier::CActiveDeviceStateNotifier()

	: CActive(EPriorityHigh)

	{

	DEBUGPRINT(test.Printf(_L("CActiveDeviceStateNotifier::CActiveDeviceStateNotifier() \n")));

	CActiveScheduler::Add(this);

	}

CActiveDeviceStateNotifier::~CActiveDeviceStateNotifier()

	{

	DEBUGPRINT(test.Printf(_L("CActiveDeviceStateNotifier::~CActiveDeviceStateNotifier() \n")));

	Cancel();

	}

void CActiveDeviceStateNotifier::DoCancel()

	{

	DEBUGPRINT(test.Printf(_L("CActiveDeviceStateNotifier::DoCancel\n")));

	gPort.AlternateDeviceStatusNotifyCancel();

	}

void CActiveDeviceStateNotifier::Activate()

	{

	gPort.AlternateDeviceStatusNotify(iStatus, iDeviceState);

	SetActive();

	}

void CActiveDeviceStateNotifier::RunL()

	{

	DEBUGPRINT(test.Printf(_L("CActiveDeviceStateNotifier::RunL() \n")));

	if (!(iDeviceState & KUsbAlternateSetting))

		{

		switch (iDeviceState)

			{

		case EUsbcDeviceStateUndefined:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Undefined \n")));

			break;

		case EUsbcDeviceStateAttached:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Attached \n")));

			break;

		case EUsbcDeviceStatePowered:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Powered \n")));

			break;

		case EUsbcDeviceStateDefault:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Default \n")));

			break;

		case EUsbcDeviceStateAddress:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Address \n")));

			break;

		case EUsbcDeviceStateConfigured:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Configured \n")));

			break;

		case EUsbcDeviceStateSuspended:

			DEBUGPRINT(test.Printf(_L("Device State notifier: Suspended \n")));

			break;

		default:

			DEBUGPRINT(test.Printf(_L("Device State notifier: !!!! NOT RECOGNISED !!!! \n")));

			}

		}

	else if (iDeviceState & KUsbAlternateSetting)

		{

		test.Printf(_L("Device State notifier: Alternate interface setting has changed: now %d \n"),

					iDeviceState & ~KUsbAlternateSetting);

		}

	Activate();

	}

CActiveStallNotifier::CActiveStallNotifier()

	: CActive(EPriorityNormal),

	  iEndpointState(0)

	{

	DEBUGPRINT(test.Printf(_L("CActiveStallNotifier::CActiveStallNotifier() \n")));

	CActiveScheduler::Add(this);

	}

CActiveStallNotifier::~CActiveStallNotifier()

	{

	DEBUGPRINT(test.Printf(_L("CActiveStallNotifier::~CActiveStallNotifier() \n")));

	Cancel();

	}

void CActiveStallNotifier::DoCancel()

	{

	DEBUGPRINT(test.Printf(_L("CActiveStallNotifier::DoCancel() \n")));

	gPort.EndpointStatusNotifyCancel();

	}

void CActiveStallNotifier::RunL()

	{

	DEBUGPRINT(test.Printf(_L("CActiveStallNotifier::RunL() \n")));

	test.Printf(_L("StallNotifier Endpointstate 0x%x\n"), iEndpointState);

	Activate();

	}

void CActiveStallNotifier::Activate()

	{

	gPort.EndpointStatusNotify(iStatus, iEndpointState);

	SetActive();

	}

//Function definitions for Class TInterface

TInterface::TInterface()

	:iAltSettingChangeSequenceNum(0)

	{ 	}

TInterface::~TInterface()

	{

	DEBUGPRINT(test.Printf(_L("TInterface::~TInterface()\n")));

	iAlternateSetting.Reset();

	}