1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\device\t_usbcsc.cpp

    15 // 

    16 //

    17 

    18 #define __E32TEST_EXTENSION__

    19 #include <e32test.h>

    20 #include <e32def.h>

    21 #include <e32def_private.h>

    22 #include <d32usbcsc.h>

    23 #include <hal.h>

    24 #include "t_usblib.h"

    25 #include <e32svr.h>

    26 #include "u32std.h"

    27 

    28 //#define DEBUGVERSION

    29 

    30 #ifdef DEBUGVERSION

    31 #define DEBUGPRINT(a) {a;}

    32 #else

    33 #define DEBUGPRINT(a) {}

    34 #endif

    35 

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

    37 

    38 _LIT(KLddName, "eusbcsc");

    39 _LIT(KUsbDeviceName, "Usbcsc");

    40 

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

    42 

    43 // Constants to be used in Descriptor Tests

    44 

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

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

    47 

    48 static const TInt KDevDesc_SpecOffset = 2;

    49 static const TInt KDevDesc_DevClassOffset = 4;

    50 static const TInt KDevDesc_DevSubClassOffset = 5;

    51 static const TInt KDevDesc_DevProtocolOffset = 6;

    52 static const TInt KDevDesc_Ep0SizeOffset = 7;

    53 static const TInt KDevDesc_VendorIdOffset = 8;

    54 static const TInt KDevDesc_ProductIdOffset = 10;

    55 static const TInt KDevDesc_DevReleaseOffset = 12;

    56 

    57 static const TInt KConfDesc_AttribOffset = 7;

    58 static const TInt KConfDesc_MaxPowerOffset = 8;

    59 

    60 static const TInt KIfcDesc_SettingOffset = 2;

    61 static const TInt KIfcDesc_ProtocolOffset = 7;

    62 

    63 static const TInt KEpDesc_PacketSizeOffset = 4;

    64 static const TInt KEpDesc_IntervalOffset = 6;

    65 static const TInt KEpDesc_SynchAddressOffset = 8;

    66 

    67 //

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

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

    70 

    71 static RDevUsbcScClient gPort;

    72 

    73 // Values to be found from device capabilities

    74 static TBool gSupportsHighSpeed;

    75 TInt gInterruptInEpFound = 0;

    76 

    77 //Command Line parameters 

    78 TBool gRealHardware = EFalse;

    79 TInt gVerbose = 0;

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

    81 TSpecTestType gSpecTest = EAll;

    82 

    83 RChunk gChunk;

    84 static const TInt gBytesReceived = 128;

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

    86 

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

    88 const TUint KDeviceToHost   = 0x80;

    89 //const TUint KDirMask		= 0x80;

    90 const TUint KDirBit			= 0x7;

    91 

    92 //const TUint KReqTypeMask	= 0x60;

    93 const TUint KReqTypeBit		= 0x5;

    94 

    95 const TUint KRecepientMask	= 0x1F;

    96 const TUint KRecepientReservedMask	= 0x1C;

    97 

    98 

    99 //Forward Declaration

   100 class TAlternateSetting;

   101 class CActiveRW;

   102 class TBuffer;

   103 class TEndpointWrapper;

   104 

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

   106 struct TEndpointDescription

   107 	{

   108 	TInt iNumOfEp;

   109 	TInt iNumOfOutEp;

   110 	TInt iNumOfInEp;

   111 	};

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

   113 class TAltSetConfig

   114 	{

   115 public:

   116 	TInt iNumOfAltSet; 

   117 	TEndpointDescription iEpsDesc[KMaxEndpointsPerClient];

   118 	};

   119 

   120 enum Tep0phase {EReady, EDataIn};

   121 

   122 struct Sep0SetupPacket

   123 	{

   124 	TUint8 iRequestType;

   125 	TUint8 iRequest;

   126 	TUint16 iwValue;

   127 	TUint16 iwIndex;

   128 	TUint16 iWlength;

   129 	};

   130 

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

   132 class CActiveConsole : public CActive

   133 	{

   134 public:

   135 	CActiveConsole();

   136 	~CActiveConsole();

   137 	void GetCharacter();

   138 

   139 private:

   140 	// Defined as pure virtual by CActive;

   141 	// implementation provided by this class.

   142 	virtual void DoCancel();

   143 	// Defined as pure virtual by CActive;

   144 	// implementation provided by this class,

   145 	virtual void RunL();

   146 	};

   147 

   148 //CActive class to monitor Device/AlternateSetting changes

   149 class CActiveDeviceStateNotifier : public CActive

   150 	{

   151 public:

   152 	CActiveDeviceStateNotifier();

   153 	~CActiveDeviceStateNotifier();

   154 	void Activate();

   155 

   156 private:

   157 	virtual void DoCancel();

   158 	virtual void RunL();

   159 

   160 private:

   161 	TUint iDeviceState;

   162 	};

   163 

   164 class CActiveStallNotifier : public CActive

   165 	{

   166 public:

   167 	CActiveStallNotifier();

   168 	~CActiveStallNotifier();

   169 	void Activate();

   170 

   171 private:

   172 	virtual void DoCancel();

   173 	virtual void RunL();

   174 

   175 private:

   176 	TUint iEndpointState;

   177 	};

   178 

   179 //Class containing all alternate settings

   180 class TInterface

   181 	{

   182 public:

   183 	TInterface();

   184 	~TInterface();

   185 	void AddAlternateSetting(TAlternateSetting &aAlternateSetting);

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

   187 	TInt GetAltSettingChangeSequenceNum();

   188 private:

   189 	void IncrementAltSettingChangeSequenceNum();

   190 private:

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

   192 	RArray <TAlternateSetting> iAlternateSetting;

   193 	};

   194 

   195 //Class containing all endpoints of an alternate setting 

   196 class TAlternateSetting

   197 	{

   198 public:

   199 	TAlternateSetting(TInt aAltSetNum);

   200 	~TAlternateSetting();

   201 	void AddEndpoint(CActiveRW &aEp); 

   202 	void SetInterfaceHandle(TInterface *aInterface);

   203 	TInt GetAlternateSetting();

   204 	TInt GetInterfaceAltSettingChangeSequenceNum();

   205 	void Activate(TBool aStartNextInAltSet = EFalse);

   206 	void SetChangeRequestFlag(CActiveRW *aEp);

   207 	TBool CheckFlagForAllOutEndpoints();

   208 	void ChangeAlternateSetting(TInt aAltsetting);

   209 private:

   210 	TInt iAltSetNum;

   211 	TInterface *iInterface;

   212 	RArray <TEndpointWrapper> iEndpoints;

   213 	};

   214 

   215 // CActive class represents an endpoint for reading or writing 

   216 class CActiveRW : public CActive

   217 	{

   218 public:

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

   220 	~CActiveRW();

   221 	void SetAlternateSettingHandle(TAlternateSetting *aAlternateSetting);	

   222 	TInt GetAlternateSettingOfEndpoint();

   223 	TBool CheckFlagForAllOutEndpoints();

   224 	TInt GetInterfaceAltSettingChangeSequenceNum();

   225 	void CallChangeAlternateSetting(TInt aAltsetting);

   226 

   227 	TInt GetEndpointNumber();

   228 	TInt GetDirection();

   229 	

   230 	void QueueRequests();	

   231 	TInt StartRead();

   232 	void StartWrite();

   233 	void SetChangeRequestFlag(TBuffer *aBuffer);

   234 

   235 private:

   236 	virtual void RunL();

   237 	virtual void DoCancel();

   238 

   239 private:

   240 	TInt iLogicalEndpointNum;	

   241 	TInt iDirection;

   242 	TAlternateSetting* iAltSetting;

   243 

   244 public:

   245 	TBuffer* iBuffer; 

   246 	};

   247 

   248 class TBuffer

   249 	{

   250 public:

   251 	TBuffer(TInt aBufNum);

   252 	~TBuffer();

   253 	void SetEndpointHandle(CActiveRW* aEndpoint);	

   254 	void SetUpHeader(); 

   255 	void ProcessData();	

   256 	void SendEP0Packet(TInt aLength);

   257 

   258 public:

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

   260 

   261 	TInt iBufNum;

   262 	TBool iIsHeaderSetUp;	// If already setUp 

   263 	

   264 	//For Ep0

   265 	Sep0SetupPacket* iSetup;	

   266 	Tep0phase iEp0Phase;	

   267 

   268 	//For Reading	

   269 	TUsbcScTransferHeader* iTransfer;

   270 	SUsbcScBufferHeader* iHeader;

   271 	TUint iMaxBufferSize;

   272 	TUint iMaxPacketSize;

   273 	TUint iBase;

   274 	TInt iOldTail; 

   275 

   276 #if _DEBUG

   277 	TUint iPrevSequence;

   278 	TUint iLoop;

   279 #endif

   280 	TInt iBytesReceived;

   281 	TInt iTickCount;

   282 	TUint iPrevAltSeq;

   283 

   284 

   285 	//For Writing

   286 	TUint iBufferOffset;

   287 	TUint iLength;

   288 	};

   289 

   290 class TEndpointWrapper

   291 	{

   292 public:

   293 	CActiveRW*	iEp;

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

   295 	};

   296 

   297 

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

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

   300    achievement in itself! */

   301 

   302 void TestBufferConstruction(TAltSetConfig* aAltSetConfig)

   303 	{

   304 	TInt r;

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

   306 	r = gPort.RealizeInterface(gChunk);

   307 	test_KErrNone(r);

   308 

   309 	TUsbcScChunkHeader chunkHeader(gChunk);

   310 

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

   312 

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

   314 

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

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

   317  													

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

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

   320 	

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

   322 

   323 	TInt maxInEps = 0, maxOutEps = 0;

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

   325 		{

   326 		TInt inEps = 0, outEps = 0;

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

   328 

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

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

   331 			{

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

   333 			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(), 

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

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

   336 				{

   337 				outEps++;

   338 				}

   339 			else 

   340 				{

   341 				inEps++;

   342 				}

   343 			}

   344 

   345 		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,

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

   347 

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

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

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

   351 		if (outEps > maxOutEps)

   352 			maxOutEps = outEps;

   353 		if (inEps > maxInEps)

   354 			maxInEps = inEps;

   355 		}

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

   357 	}

   358 

   359 // Function Definitions *****

   360 

   361 TInt WaitUntilTimeout(TInt aTimout, TRequestStatus& aStatus)

   362 {

   363 	TRequestStatus timerStatus;

   364 	RTimer timer;

   365 	test_KErrNone(timer.CreateLocal());

   366 	timer.After(timerStatus,aTimout*1000);

   367 	User::WaitForRequest(timerStatus, aStatus);

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

   369 }

   370 

   371 // Class CActiveConsole

   372 

   373 CActiveConsole::CActiveConsole()

   374 	: CActive(EPriorityHigh)

   375 	{

   376 	CActiveScheduler::Add(this);

   377 	}

   378 

   379 CActiveConsole::~CActiveConsole()

   380 	{

   381 	Cancel();

   382 	}

   383 

   384 void CActiveConsole::GetCharacter()

   385 	{

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

   387 

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

   389 	SetActive();

   390 	}

   391 

   392 void CActiveConsole::DoCancel()

   393 	{

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

   395 	test.Console()->ReadCancel();

   396 	}

   397 

   398 void CActiveConsole::RunL()

   399 	{

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

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

   402 		{

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

   404 		CActiveScheduler::Stop();

   405 		return;

   406 		}

   407 	GetCharacter();

   408 	}

   409 

   410 // Class CActiveDeviceStateNotifier

   411 CActiveDeviceStateNotifier::CActiveDeviceStateNotifier()

   412 	: CActive(EPriorityHigh)

   413 	{

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

   415 	CActiveScheduler::Add(this);

   416 	}

   417 

   418 CActiveDeviceStateNotifier::~CActiveDeviceStateNotifier()

   419 	{

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

   421 	Cancel();

   422 	}

   423 

   424 void CActiveDeviceStateNotifier::DoCancel()

   425 	{

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

   427 	gPort.AlternateDeviceStatusNotifyCancel();

   428 	}

   429 

   430 void CActiveDeviceStateNotifier::Activate()

   431 	{

   432 	gPort.AlternateDeviceStatusNotify(iStatus, iDeviceState);

   433 	SetActive();

   434 	}

   435 

   436 void CActiveDeviceStateNotifier::RunL()

   437 	{

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

   439 	if (!(iDeviceState & KUsbAlternateSetting))

   440 		{

   441 		switch (iDeviceState)

   442 			{

   443 		case EUsbcDeviceStateUndefined:

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

   445 			break;

   446 		case EUsbcDeviceStateAttached:

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

   448 			break;

   449 		case EUsbcDeviceStatePowered:

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

   451 			break;

   452 		case EUsbcDeviceStateDefault:

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

   454 			break;

   455 		case EUsbcDeviceStateAddress:

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

   457 			break;

   458 		case EUsbcDeviceStateConfigured:

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

   460 			break;

   461 		case EUsbcDeviceStateSuspended:

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

   463 			break;

   464 		default:

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

   466 			}

   467 		}

   468 	else if (iDeviceState & KUsbAlternateSetting)

   469 		{

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

   471 					iDeviceState & ~KUsbAlternateSetting);

   472 		}

   473 	Activate();

   474 	}

   475 

   476 

   477 

   478 CActiveStallNotifier::CActiveStallNotifier()

   479 	: CActive(EPriorityNormal),

   480 	  iEndpointState(0)

   481 	{

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

   483 	CActiveScheduler::Add(this);

   484 	}

   485 

   486 CActiveStallNotifier::~CActiveStallNotifier()

   487 	{

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

   489 	Cancel();

   490 	}

   491 

   492 void CActiveStallNotifier::DoCancel()

   493 	{

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

   495 	gPort.EndpointStatusNotifyCancel();

   496 	}

   497 

   498 void CActiveStallNotifier::RunL()

   499 	{

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

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

   502 	Activate();

   503 	}

   504 

   505 void CActiveStallNotifier::Activate()

   506 	{

   507 	gPort.EndpointStatusNotify(iStatus, iEndpointState);

   508 	SetActive();

   509 	}

   510 

   511 

   512 

   513 

   514 

   515 

   516 

   517 //Function definitions for Class TInterface

   518 

   519 TInterface::TInterface()

   520 	:iAltSettingChangeSequenceNum(0)

   521 	{ 	}

   522 

   523 TInterface::~TInterface()

   524 	{

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

   526 	iAlternateSetting.Reset();

   527 	}

   528 

   529 void TInterface::AddAlternateSetting(TAlternateSetting &aAlternateSetting)

   530 	{

   531 	aAlternateSetting.SetInterfaceHandle(this);

   532 	iAlternateSetting.Append(aAlternateSetting);

   533 	}

   534 

   535 void TInterface::SetActiveAlternateSetting(TInt aSettingNum, TBool aStartNextInAltSet)

   536 	{

   537 	if (aStartNextInAltSet)

   538 		{

   539 		IncrementAltSettingChangeSequenceNum();

   540 		test.Printf(_L("ALTERNATE SETTING CHANGE! Calling StartNextInAlternateSetting() \n"));

   541 		TInt r = gPort.StartNextInAlternateSetting();

   542 		test_Compare((r&0xFFFF), ==, aSettingNum);

   543 		}

   544 

   545 	iAlternateSetting[aSettingNum].Activate(aStartNextInAltSet);

   546 	}

   547 

   548 void TInterface::IncrementAltSettingChangeSequenceNum()

   549 	{

   550 	iAltSettingChangeSequenceNum++;

   551 	}

   552 TInt TInterface::GetAltSettingChangeSequenceNum()

   553 	{

   554 	return iAltSettingChangeSequenceNum;

   555 	}

   556 

   557 TAlternateSetting::TAlternateSetting(TInt aAltSetNum)

   558 	:iAltSetNum(aAltSetNum)

   559 	{	}

   560 

   561 //Function definitions for Class TAlternateSetting

   562 

   563 TAlternateSetting::~TAlternateSetting()

   564 	{

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

   566 	iEndpoints.Reset();

   567 	}

   568 

   569 void TAlternateSetting::AddEndpoint(CActiveRW &aEndpoint)

   570 	{

   571 	TEndpointWrapper* wrapper = new TEndpointWrapper();

   572 	test_NotNull(wrapper);

   573 

   574 	aEndpoint.SetAlternateSettingHandle(this);

   575 	

   576 	wrapper->iEp = &aEndpoint;

   577 	wrapper->iSettingChangeReceived = EFalse;

   578 	

   579 	iEndpoints.Append(*wrapper);

   580 	delete wrapper;

   581 	}

   582 

   583 void TAlternateSetting::SetInterfaceHandle(TInterface *aInterface)

   584 	{

   585 	iInterface = aInterface;

   586 	}

   587 

   588 TInt TAlternateSetting::GetAlternateSetting()

   589 	{

   590 	return iAltSetNum;

   591 	}

   592 

   593 TInt TAlternateSetting::GetInterfaceAltSettingChangeSequenceNum()

   594 	{

   595 	return iInterface->GetAltSettingChangeSequenceNum();

   596 	}

   597 

   598 

   599 void TAlternateSetting::Activate(TBool aStartNextInAltSet)

   600 	{

   601 	// set handle for Ep0

   602 	for(TInt count = 0; count < iEndpoints.Count(); count++)

   603 		{

   604 		if(iEndpoints[count].iEp->GetEndpointNumber() == 0)

   605 			{

   606 			iEndpoints[count].iEp->SetAlternateSettingHandle(this);

   607 			break;

   608 			}

   609 		}

   610 

   611 	if (gSpecTest == EAltSet)

   612 		test.Printf(_L("On host side, on the Interface Tab, Change to a differnt Alternate Setting and read or write from an endpoint in the new alternate setting \n\n"));

   613 

   614 	if (aStartNextInAltSet)

   615 		{

   616 		iEndpoints[0].iSettingChangeReceived = EFalse;

   617 		iEndpoints[0].iEp->QueueRequests();

   618 		

   619 

   620 		for (TInt i = 1; i < iEndpoints.Count() ; i++)	// Not including EP0

   621 			{

   622 			iEndpoints[i].iEp->iBuffer->SetEndpointHandle(iEndpoints[i].iEp);

   623 			iEndpoints[i].iSettingChangeReceived = EFalse;

   624 			

   625 			if (iEndpoints[i].iEp->iBuffer->iIsHeaderSetUp)

   626 				{

   627 				iEndpoints[i].iEp->QueueRequests();

   628 				}

   629 			else

   630 				{

   631 				//Set up Header as before

   632 				iEndpoints[i].iEp->iBuffer->iIsHeaderSetUp = ETrue;

   633 				iEndpoints[i].iEp->iBuffer->SetUpHeader();

   634 				}

   635 			}

   636 		}

   637 	else

   638 		{

   639 		for (TInt i = 0; i < iEndpoints.Count() ; i++)

   640 			{

   641 			iEndpoints[i].iEp->iBuffer->SetEndpointHandle(iEndpoints[i].iEp);

   642 			iEndpoints[i].iEp->iBuffer->iIsHeaderSetUp = ETrue;

   643 

   644 			iEndpoints[i].iSettingChangeReceived = EFalse;

   645 			iEndpoints[i].iEp->iBuffer->SetUpHeader();

   646 			}

   647 		}

   648 	}

   649 

   650 void CActiveRW::QueueRequests()

   651 	{

   652 	DEBUGPRINT(test.Printf(_L("CActiveRW::QueueRequests() for Buffer number iBufNum %d AlternateSetting %d iDirection %d\n"),

   653 												iBuffer->iBufNum, iAltSetting->GetAlternateSetting(), iDirection));

   654 	if (!IsActive())

   655 		{

   656 		if (iDirection != KUsbScHdrEpDirectionIn)

   657 			{

   658 			TInt r = StartRead();

   659 			if (r == KErrCompletion)

   660 				RunL();

   661 			else if (r == KErrNone)

   662 				SetActive();

   663 			}

   664 		else

   665 			StartWrite();

   666 		}

   667 	}

   668 

   669 void TAlternateSetting::SetChangeRequestFlag(CActiveRW *aEp)

   670 	{

   671 	DEBUGPRINT(test.Printf(_L("Set ChangeRequestFlag to True for Buffer Number = %d \n"), aEp->iBuffer->iBufNum));

   672 

   673 	TInt countOfEndpoints = iEndpoints.Count();

   674 

   675 	for(TInt count = 0; count < countOfEndpoints; count++)

   676 		{

   677 		if(iEndpoints[count].iEp->iBuffer->iBufNum == aEp->iBuffer->iBufNum)

   678 			{

   679 			iEndpoints[count].iSettingChangeReceived = ETrue;

   680 			break;

   681 			}

   682 		}

   683 	}

   684 

   685 TBool TAlternateSetting::CheckFlagForAllOutEndpoints()

   686 	{

   687 	// now check if we have received Alternate Setting requests for all out EPs

   688 	TInt countOfEndpoints = iEndpoints.Count();

   689 	TBool settingRequestReceivedForAllEps = ETrue;

   690 	for(TInt count = 0; count < countOfEndpoints; count++) 

   691 		{

   692 		if((iEndpoints[count].iEp->GetDirection() != KUsbScHdrEpDirectionIn) && !iEndpoints[count].iSettingChangeReceived)

   693 			{

   694 			settingRequestReceivedForAllEps = EFalse;

   695 			break;

   696 			}

   697 		}

   698 	

   699 	return settingRequestReceivedForAllEps;

   700 	}

   701 

   702 void TAlternateSetting::ChangeAlternateSetting(TInt aAltSetting)

   703 	{

   704 	iInterface->SetActiveAlternateSetting(aAltSetting, ETrue);

   705 	}

   706 

   707 //Function definitions for Class CActiveRW

   708 CActiveRW::CActiveRW(TInt aEndpointNum, TInt aDirection, TBuffer* aBuffer)

   709 	: CActive(EPriorityNormal),

   710 		iLogicalEndpointNum(aEndpointNum),

   711 		iDirection(aDirection)

   712 	{

   713 	CActiveScheduler::Add(this);

   714 	iBuffer = aBuffer;

   715 	}

   716 

   717 CActiveRW::~CActiveRW()

   718 	{

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

   720 	Cancel();

   721 	}

   722 

   723 void CActiveRW::DoCancel()

   724 	{

   725 	DEBUGPRINT(test.Printf(_L("CActiveRW::DoCancel for Buffer number iBufNum %d AlternateSetting %d\n"),

   726 												iBuffer->iBufNum, iAltSetting->GetAlternateSetting()));

   727 	if (IsActive())

   728 		{

   729 		if (iDirection == KUsbScHdrEpDirectionOut)

   730 			gPort.ReadCancel(iBuffer->iBufNum);

   731 		else if (iDirection == KUsbScHdrEpDirectionIn)

   732 			gPort.WriteCancel(iBuffer->iBufNum);

   733 		else 

   734 			{

   735 			gPort.WriteCancel(iBuffer->iBufNum);

   736 			gPort.ReadCancel(iBuffer->iBufNum);

   737 			}

   738 		}

   739 	}

   740 

   741 void CActiveRW::SetAlternateSettingHandle(TAlternateSetting *aAlternateSetting)

   742 	{

   743 	iAltSetting = aAlternateSetting;

   744 	}

   745 

   746 TInt CActiveRW::GetAlternateSettingOfEndpoint()

   747 	{

   748 	return iAltSetting->GetAlternateSetting();

   749 	}

   750 

   751 TBool CActiveRW::CheckFlagForAllOutEndpoints()

   752 	{

   753 	return iAltSetting->CheckFlagForAllOutEndpoints();

   754 	}

   755 

   756 TInt CActiveRW::GetInterfaceAltSettingChangeSequenceNum()

   757 	{

   758 	return iAltSetting->GetInterfaceAltSettingChangeSequenceNum();

   759 	}

   760 

   761 void CActiveRW::CallChangeAlternateSetting(TInt aAltsetting)

   762 	{

   763 	iAltSetting->ChangeAlternateSetting(aAltsetting);

   764 	}

   765 

   766 void CActiveRW::SetChangeRequestFlag(TBuffer *aBuffer)

   767 	{

   768 	iAltSetting->SetChangeRequestFlag(this);

   769 	}

   770 

   771 TInt CActiveRW::GetEndpointNumber()

   772 	{

   773 	return iLogicalEndpointNum;

   774 	}

   775 

   776 TInt CActiveRW::GetDirection()

   777 	{

   778 	return iDirection;

   779 	}

   780 

   781 //Prototypes 

   782 void LoadDriver();

   783 void OpenChannel();

   784 void CloseChannel();

   785 void UnloadDriver();

   786 void TestMultipleChannels();

   787 void CheckDeviceCapabilities();

   788 TInt SettingOne(TInt aAltSetNo);

   789 TInt SettingTwo(TInt aAltSetNo);

   790 TInt SettingThreeIn(TInt aAltSetNo);

   791 TInt SettingFourOut(TInt aAltSetNo);

   792 TInt SettingFive(TInt aAltSetNo);

   793 TInt InvalidSettingOne(TInt aAltSetNo);

   794 TInt InvalidSettingTwo(TInt aAltSetNo);

   795 TInt InvalidSettingThree(TInt aAltSetNo);

   796 

   797 void TestBufferHandling()

   798 	{

   799 	LoadDriver();

   800 	OpenChannel();

   801 

   802 	TAltSetConfig *altSetConfig = new TAltSetConfig;

   803 	altSetConfig->iNumOfAltSet = 1;

   804 	TEndpointDescription temp = {2,1,1}; 

   805 	altSetConfig->iEpsDesc[0] = temp; 

   806 

   807 	test_KErrNone(SettingOne(0));	

   808 	if (gSpecTest==EAltSet)

   809 		{

   810 		test_KErrNone(SettingTwo(1));

   811 		test_KErrNone(SettingThreeIn(2));	

   812 		test_KErrNone(SettingFourOut(3));

   813 

   814 		altSetConfig->iNumOfAltSet = 4;

   815 		TEndpointDescription temp1 = {5,4,1}; 

   816 		TEndpointDescription temp2 = {3,0,3}; 

   817 		TEndpointDescription temp3 = {3,3,0};

   818 		

   819 		altSetConfig->iEpsDesc[1] = temp1;	

   820 		altSetConfig->iEpsDesc[2] = temp2; 

   821 		altSetConfig->iEpsDesc[3] = temp3; 

   822 		}

   823 

   824 	TInt r = gPort.RealizeInterface(gChunk);

   825 	test_KErrNone(r);

   826 

   827 	if (gRealHardware)

   828 		{

   829 		TUsbcScChunkHeader chunkHeader(gChunk);

   830 		

   831 		test.Printf(_L("\n \n Trying hardware\nPlease start the Host side application...\n"));

   832 

   833 		TRequestStatus status;

   834 		gPort.ReEnumerate(status);

   835 		User::WaitForRequest(status);

   836 

   837 		TUsbcDeviceState device_state =	EUsbcDeviceStateUndefined;

   838 		TInt r = gPort.DeviceStatus(device_state);

   839 		if (r != KErrNone)

   840 			{

   841 			test.Printf(_L("Error %d on querying device state"), r);

   842 			}

   843 		else

   844 			{

   845 			DEBUGPRINT(test.Printf(_L("Current device state: %s \n"),

   846 						(device_state == EUsbcDeviceStateUndefined) ? _S("Undefined") :

   847 						((device_state == EUsbcDeviceStateAttached) ? _S("Attached") :

   848 						 ((device_state == EUsbcDeviceStatePowered) ? _S("Powered") :

   849 						  ((device_state == EUsbcDeviceStateDefault) ? _S("Default") :

   850 						   ((device_state == EUsbcDeviceStateAddress) ? _S("Address") :

   851 							((device_state == EUsbcDeviceStateConfigured) ? _S("Configured") :

   852 							 ((device_state == EUsbcDeviceStateSuspended) ? _S("Suspended") :

   853 							  _S("Unknown")))))))));

   854 			}

   855 

   856 		CActiveScheduler* myScheduler = new (ELeave) CActiveScheduler();

   857 		CActiveScheduler::Install(myScheduler);

   858 

   859 	__UHEAP_MARK;

   860 

   861 		CActiveConsole* myActiveConsole = new CActiveConsole();

   862 		myActiveConsole->GetCharacter();

   863 

   864 		CActiveDeviceStateNotifier* myDeviceStateNotifier = new CActiveDeviceStateNotifier();

   865 		myDeviceStateNotifier->Activate();

   866 

   867 		CActiveStallNotifier* myEndpointStateNotifier = new CActiveStallNotifier();

   868 		myEndpointStateNotifier->Activate();

   869 

   870 		TBuffer* bufferEp0 = new TBuffer(KUsbcScEndpointZero);

   871 

   872 		// Keep an array of pointer of Buffers 

   873 		TBuffer* bufferArray[KUsbcMaxBuffers];

   874 		for(TInt i = 0; i < chunkHeader.iBuffers->NumberOfBuffers(); i++)

   875 			{

   876 			TBuffer* buf = new TBuffer(i);

   877 			bufferArray[i] = buf;

   878 			}

   879 		

   880 		TInterface* interface1 = new TInterface;

   881 		TAlternateSetting* alternateSetting;

   882 		

   883 		// Keep an array of pointer of the alternate settings

   884 		TAlternateSetting** altSetArray;

   885 		altSetArray = new TAlternateSetting *[KUsbcMaxAltSetting]; 

   886 		TInt number = 0;

   887 

   888 

   889 		CActiveRW *endpoint0 = new CActiveRW(0,KUsbScHdrEpDirectionBiDir, bufferEp0);

   890 		

   891 		// Keep an array of pointer of Endpoints 

   892 		CActiveRW** array;

   893 		array = new CActiveRW *[KUsbcMaxEndpoints];

   894 		TInt count = 0;

   895 		array[count++] = endpoint0;

   896 

   897 		

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

   899 			{

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

   901 			alternateSetting = new TAlternateSetting(i);

   902 			alternateSetting->AddEndpoint(*endpoint0);

   903 			

   904 			for (TInt epNum = 1; epNum <= chunkHeader.GetNumberOfEndpoints(i); epNum++)

   905 				{

   906 				TUsbcScHdrEndpointRecord* endpointInf = (TUsbcScHdrEndpointRecord*) &(iEp[epNum * chunkHeader.iAltSettings->iEpRecordSize]);

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

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

   909 				CActiveRW *EndpointRW = new CActiveRW(epNum, endpointInf->Direction(), bufferArray[endpointInf->iBufferNo]);

   910 				alternateSetting->AddEndpoint(*EndpointRW);

   911 				array[count++] = EndpointRW;

   912 				}

   913 			altSetArray[number++] = alternateSetting;

   914 			interface1->AddAlternateSetting(*alternateSetting);

   915 			}

   916 

   917 		interface1->SetActiveAlternateSetting(0);

   918 		CActiveScheduler::Start();

   919 //		User::After(2000000);

   920 		

   921 		test.Printf(_L("Cleaning Up \n"));

   922 	

   923 		test.Printf(_L("Delete endpoint array \n"));

   924 		for(TInt i = 0;  i < count; i++)

   925 			{

   926 			delete array[i];

   927 			}

   928 		delete [] array;

   929 

   930 		test.Printf(_L("Delete altset array \n"));

   931 		for (TInt i = 0; i < number; i++)

   932 			{

   933 			delete altSetArray[i];

   934 			}

   935 		delete [] altSetArray;

   936 

   937 		delete interface1;

   938 	

   939 		test.Printf(_L("Delete buffer array \n"));

   940 		for(TInt i = 0; i < chunkHeader.iBuffers->NumberOfBuffers(); i++)

   941 			{

   942 			delete bufferArray[i];

   943 			}

   944 		test.Printf(_L("Delete buffer ep0 \n"));

   945 		delete bufferEp0;

   946 	

   947 		delete myEndpointStateNotifier;

   948 		delete myDeviceStateNotifier;

   949 		delete myActiveConsole;

   950 	

   951 	__UHEAP_MARKEND;

   952 

   953 		test.Printf(_L("Uninstalling scheduler \n"));

   954 

   955 		CActiveScheduler::Install(NULL); // Uninstalling the scheduler

   956 		delete myScheduler;			

   957 		}

   958 	delete altSetConfig;

   959 	

   960 	CloseChannel();

   961 	UnloadDriver();

   962 	}

   963 

   964 //To do Move Around Later

   965 //Function definitions for Class TBuffer

   966 TBuffer::TBuffer(TInt aBufNum)

   967 		:iBufNum(aBufNum),

   968 		 iIsHeaderSetUp(EFalse),

   969 	     iSetup(NULL),		//Ep0

   970 		 iTransfer(NULL),

   971 		 iHeader(NULL),

   972 		 iOldTail(0),

   973 		 iBytesReceived(0),

   974 		 iTickCount(0),

   975 		 iPrevAltSeq(0)

   976 	{

   977 	iBase = (TUint) gChunk.Base();

   978 	}

   979 

   980 TBuffer::~TBuffer()

   981 	{ }

   982 

   983 void TBuffer::SetEndpointHandle(CActiveRW* aEndpoint)

   984 	{

   985 	iEndpoint = aEndpoint;

   986 	}

   987 

   988 void TBuffer::SendEP0Packet(TInt aLength)

   989 	{

   990 	const char testString[] = "Once upon a time, there was a developer, that really did dispair. ";

   991 	TUint8* data;

   992 	TInt maxSize;

   993 	TUsbcScChunkHeader chunkHeader(gChunk); 

   994 

   995 	iBufferOffset = chunkHeader.iBuffers->Ep0In()->Offset();

   996 	data = (TUint8*) (((TUint) iBufferOffset  + iBase));

   997 

   998 	maxSize = chunkHeader.iBuffers->Ep0In()->Size();

   999 	test_Compare(maxSize, >= ,  aLength);

  1000 

  1001 	TInt strPos=0;

  1002 	TInt i;

  1003 	for (i=0; i<aLength; i++, strPos++)

  1004 		{

  1005 		if (testString[strPos]==0)

  1006 			strPos=0;

  1007 		data[i]=testString[strPos];

  1008 		}

  1009 	test.Printf(_L("Sending data....."));

  1010 	// copy data into buffer TO DO

  1011 	gPort.WriteData(KUsbcScEndpointZero,  iBufferOffset, aLength, 0, iEndpoint->iStatus);

  1012 	User::WaitForRequest(iEndpoint->iStatus);

  1013 	test_KErrNone(iEndpoint->iStatus.Int());

  1014 	test.Printf(_L("Sent!\n"));

  1015 	}

  1016 

  1017 _LIT(KUndefined,"Undefined"); _LIT(KAttached,"KAttached"); _LIT(KPowered,"KPowered"); _LIT(KDefault,"Default");

  1018 _LIT(KAddress,"Address"); _LIT(KConfigured,"Configured"); _LIT(KSuspended,"Suspended"); _LIT(KOther," <?> ");

  1019 const TDesC* const KStates[8] = {&KUndefined,&KAttached,&KPowered,&KDefault,&KAddress,&KConfigured,&KSuspended,&KOther};

  1020 

  1021 void TBuffer::SetUpHeader()

  1022 	{

  1023 	DEBUGPRINT(test.Printf(_L("CActiveRW::SetUpHeader() for Buffer %d belonging to Endpoint %d in Alternate Setting %d \n"), 

  1024 								iBufNum, iEndpoint->GetEndpointNumber(), iEndpoint->GetAlternateSettingOfEndpoint()));

  1025 	TUsbcScChunkHeader chunkHeader(gChunk);

  1026 	TUsbcScHdrEndpointRecord* epInfo;

  1027 

  1028 #if _DEBUG

  1029 	iLoop =0;

  1030 #endif

  1031 	iEp0Phase=EReady;

  1032 	

  1033 	if (iEndpoint->GetEndpointNumber() == 0)

  1034 		{

  1035 		if ((gSpecTest == EEp0) || (gSpecTest == EAltSet))

  1036 			{

  1037 			iBufNum = KUsbcScEndpointZero;

  1038 			iHeader = (SUsbcScBufferHeader*) (( (TInt) chunkHeader.iBuffers->Ep0Out()->Offset()) + iBase);

  1039 

  1040 			// To check instance of Alternate Setting Sequence Number

  1041 			iTransfer = (TUsbcScTransferHeader*) (iHeader->iTail + iBase);

  1042 

  1043 			iMaxBufferSize = chunkHeader.iBuffers->Ep0Out()->Size();

  1044 			DEBUGPRINT(test.Printf(_L("MaxBufferSize %d \n"), iMaxBufferSize));

  1045 

  1046 			TUint ep0MaxPacketSize = gPort.EndpointZeroMaxPacketSizes();

  1047 			DEBUGPRINT(test.Printf(_L("ep0 Max Packet Size = %d\n"), ep0MaxPacketSize));

  1048 

  1049 			iMaxPacketSize = (ep0MaxPacketSize == KUsbEpSize64) ? 64 :

  1050 				((ep0MaxPacketSize == KUsbEpSize32) ? 32 :

  1051 					((ep0MaxPacketSize == KUsbEpSize16) ? 16 :

  1052 						((ep0MaxPacketSize == KUsbEpSize8) ? 8 : 0)));

  1053 				

  1054 			test_Compare(iMaxPacketSize,>,0);

  1055 			if (gSpecTest == EEp0)

  1056 				test.Printf(_L("Writing from buffer %d \n On host side, on the Class or Vendor Request Tab, send a Vendor request from an Interface on Device-to-Host or Host-to-Device(to an Interface) \n\n"), iBufNum);

  1057 			iEndpoint->QueueRequests();

  1058 			}

  1059 		}

  1060 	else

  1061 		{

  1062 		TInt r;

  1063 		TBuf8<KUsbDescSize_Endpoint> endpointSizeDescriptor;

  1064 

  1065 		r = gPort.GetEndpointDescriptor(iEndpoint->GetAlternateSettingOfEndpoint(), iEndpoint->GetEndpointNumber(), endpointSizeDescriptor);

  1066 		test_KErrNone(r);

  1067 		iMaxPacketSize = EpSize(endpointSizeDescriptor[KEpDesc_PacketSizeOffset], endpointSizeDescriptor[KEpDesc_PacketSizeOffset+1]);

  1068 		test_Compare(iMaxPacketSize,>,0);

  1069 		DEBUGPRINT(test.Printf(_L("Endpoint %d Max Packet Size = %d\n"), iEndpoint->GetEndpointNumber(), iMaxPacketSize));

  1070 	

  1071 		if (iEndpoint->GetDirection() == KUsbScHdrEpDirectionOut)

  1072 			{

  1073 			if ((gSpecTest == EBufRead) || (gSpecTest == EAltSet))

  1074 				{

  1075 				TUsbcScBufferRecord* buff = chunkHeader.GetBuffer(iEndpoint->GetAlternateSettingOfEndpoint(), iEndpoint->GetEndpointNumber(), epInfo);

  1076 				test_NotNull(buff);

  1077 				iHeader = (SUsbcScBufferHeader *) (buff->Offset() + iBase);

  1078 				// To check instance of Alternate Setting Sequence Number

  1079 				iTransfer = (TUsbcScTransferHeader*) (iHeader->iTail + iBase);

  1080  				iMaxBufferSize = buff->Size();

  1081 

  1082 				if (gSpecTest == EBufRead)

  1083 					test.Printf(_L("Reading from buffer %d \n On host side, on the Pipes Tab, please select endpoint %d and read from a file and send to pipe\n"), iBufNum, iEndpoint->GetEndpointNumber());

  1084 				iEndpoint->QueueRequests();

  1085 				}

  1086 			}

  1087 

  1088 		if (iEndpoint->GetDirection() == KUsbScHdrEpDirectionIn)

  1089 			{

  1090 			if ((gSpecTest == EBufWrite) || (gSpecTest == EAltSet))

  1091 				{

  1092 				const char testString[] = "Hello, this is a test! Its not very exciting, but it does demonstrate if USBCSC can write to the IN endpoint.  Please dont keep reading this file, if your expecting great works of litrature, for there will be none.  To be honest, i'm not even sure why the test is going on this long with these insain ramballings.  Never mind a!  I guess at this point i think i should sum up by stateing that if you got this far, USBC probebly works to some degree.  However really you need to see if it can write this lots of times.  And i dont just mean this sentance, but the entire buffer.  For a teat i'll sing you a song. Ten green bottles, Hanging on the wall, Ten green bottles, Hanging on the wall, And if one green bottle, Should accidentally fall, There'll be nine green bottles, Hanging on the wall.   Nine green bottles, Hanging on the wall,  Nine green bottles, Hanging on the wall,  And if one green bottle, Should accidentally fall . . .  you get the idea.  Ok, I started by ramble by saying \"";

  1093 

  1094 				TUsbcScBufferRecord* buff = chunkHeader.GetBuffer(iEndpoint->GetAlternateSettingOfEndpoint(), iEndpoint->GetEndpointNumber(), epInfo);

  1095 				iBufferOffset = buff->Offset(); 	

  1096 				iLength       = buff->Size();

  1097 

  1098 				TUint8* buffer = (TUint8*) (iBufferOffset + iBase);

  1099 

  1100 				TUint i;

  1101 				TInt strPos=0;

  1102 				for (i=0; i<iLength; i++, strPos++)

  1103 					{

  1104 					if (testString[strPos]==0)

  1105 						strPos=0;

  1106 					buffer[i]=testString[strPos];

  1107 					}

  1108 				buffer[iLength-1] = '$'; 

  1109 				if (gSpecTest == EBufWrite)

  1110 					test.Printf(_L("Writing from buffer %d \n On host side, on the Pipes Tab, please select endpoint %d and read from pipe and write to file \n"), iBufNum, iEndpoint->GetEndpointNumber());

  1111 				iEndpoint->QueueRequests();

  1112 				}

  1113 			}

  1114 		}

  1115 	}

  1116 

  1117 TInt CActiveRW::StartRead()

  1118 	{

  1119 	TInt r = gPort.ReadDataNotify(iBuffer->iBufNum,iStatus);

  1120 	return r;

  1121 	}

  1122 

  1123 void CActiveRW::StartWrite()

  1124 	{

  1125 	// Test if starting address is aligned

  1126 	test_Compare( ((iBuffer->iBufferOffset + iBuffer->iBase) % iBuffer->iMaxPacketSize), ==, 0);

  1127 	gPort.WriteData(iBuffer->iBufNum,  iBuffer->iBufferOffset, iBuffer->iLength, 0 /*flags*/ ,iStatus);

  1128 	if (iStatus.Int() != KErrEof)

  1129 		SetActive();

  1130 	}

  1131 

  1132 void CActiveRW::RunL()

  1133 	{

  1134 	DEBUGPRINT(test.Printf(_L("CActiveRW::RunL for Buffer number iBufNum %d AlternateSetting %d iDirection %d\n"),