1 // Copyright (c) 2003-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_usbapi.cpp

    15 // Overview:

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

    17 // API Information:

    18 // Details:

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

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

    21 // state machine enclosed for clarity):

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

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

    24 // - Test allocating DMA and double buffering resources with

    25 // AllocateEndpointResource results in their use being correctly reported by

    26 // QueryEndpointResourceUse

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

    28 // interface, alternate interface, endpoint and string descriptor

    29 // manipulation.

    30 // HS: device_qualifier and other_speed_configuation descriptors.

    31 // - Check and validate the EndpointZeroMaxPacketSizes.

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

    33 // control, AlternateDeviceStatusNotify, EndpointStatusNotify

    34 // - Test HaltEndpoint and ClearHaltEndpoint correctly result in endpoint

    35 // status being reported as stalled/not stalled.

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

    37 // - Close and free the logical device.

    38 // Platforms/Drives/Compatibility:

    39 // All.

    40 // Assumptions/Requirement/Pre-requisites:

    41 // Failures and causes:

    42 // Base Port information:

    43 // 

    44 //

    45 

    46 

    47 #include <e32test.h>

    48 #include <e32debug.h>

    49 #include <hal.h>

    50 #include <d32usbc.h>

    51 #include <d32otgdi.h>

    52 

    53 #include "t_usblib.h"

    54 

    55 

    56 // --- Local Top Level Variables

    57 

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

    59 static RDevUsbcClient gPort;

    60 static RUsbOtgDriver gOTG;

    61 static TBool gSupportsOtg;

    62 static TBool gSupportsHighSpeed;

    63 static TBool gUsingHighSpeed;

    64 static TBool gSoak;

    65 static TChar gKeychar = 'a';

    66 

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

    68 static TInt INT_IN_ep = -1;

    69 

    70 _LIT(KUsbLddFilename, "eusbc");

    71 _LIT(KOtgdiLddFilename, "otgdi");

    72 _LIT(KUsbDeviceName, "Usbc");

    73 

    74 

    75 // --- Local Constants

    76 

    77 static const TInt KUsbDesc_SizeOffset = 0;

    78 static const TInt KUsbDesc_TypeOffset = 1;

    79 

    80 static const TInt KDevDesc_SpecOffset = 2;

    81 static const TInt KDevDesc_DevClassOffset = 4;

    82 static const TInt KDevDesc_DevSubClassOffset = 5;

    83 static const TInt KDevDesc_DevProtocolOffset = 6;

    84 static const TInt KDevDesc_Ep0SizeOffset = 7;

    85 static const TInt KDevDesc_VendorIdOffset = 8;

    86 static const TInt KDevDesc_ProductIdOffset = 10;

    87 static const TInt KDevDesc_DevReleaseOffset = 12;

    88 

    89 static const TInt KConfDesc_AttribOffset = 7;

    90 static const TInt KConfDesc_MaxPowerOffset = 8;

    91 

    92 static const TInt KIfcDesc_SettingOffset = 2;

    93 static const TInt KIfcDesc_ProtocolOffset = 7;

    94 

    95 static const TInt KEpDesc_PacketSizeOffset = 4;

    96 static const TInt KEpDesc_IntervalOffset = 6;

    97 static const TInt KEpDesc_SynchAddressOffset = 8;

    98 

    99 

   100 //

   101 // Helper.

   102 //

   103 static TEndpointState QueryEndpointState(TEndpointNumber aEndpoint)

   104 	{

   105 	TEndpointState ep_state = EEndpointStateUnknown;

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

   107 	test(r == KErrNone);

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

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

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

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

   112 	return ep_state;

   113 	}

   114 

   115 

   116 // --- Class CActiveKeypressNotifier

   117 

   118 class CActiveKeypressNotifier : public CActive

   119 	{

   120 public:

   121 	static CActiveKeypressNotifier* NewL(CConsoleBase* aConsole);

   122 	~CActiveKeypressNotifier();

   123 	void RequestCharacter();

   124 	void ProcessKeyPressL(TChar aChar);

   125 private:

   126 	virtual void DoCancel();

   127 	virtual void RunL();

   128 	CActiveKeypressNotifier(CConsoleBase* aConsole);

   129 	void ConstructL() {};

   130 private:

   131 	CConsoleBase* iConsole;

   132 	};

   133 

   134 

   135 CActiveKeypressNotifier* CActiveKeypressNotifier::NewL(CConsoleBase* aConsole)

   136 	{

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

   138 	CleanupStack::PushL(self);

   139 	self->ConstructL();

   140 	CActiveScheduler::Add(self);

   141 	CleanupStack::Pop();

   142 	return self;

   143 	}

   144 

   145 

   146 CActiveKeypressNotifier::CActiveKeypressNotifier(CConsoleBase* aConsole)

   147 	: CActive(EPriorityNormal), iConsole(aConsole)

   148 	{}

   149 

   150 

   151 CActiveKeypressNotifier::~CActiveKeypressNotifier()

   152 	{

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

   154 	}

   155 

   156 

   157 void CActiveKeypressNotifier::RunL()

   158 	{

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

   160 	RequestCharacter();

   161 	}

   162 

   163 

   164 void CActiveKeypressNotifier::DoCancel()

   165 	{

   166 	iConsole->ReadCancel();

   167 	}

   168 

   169 

   170 void CActiveKeypressNotifier::RequestCharacter()

   171 	{

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

   173 	if (IsActive())

   174 		{

   175 		return;

   176 		}

   177 	iConsole->Read(iStatus);

   178 	SetActive();

   179 	}

   180 

   181 

   182 // --- Actual Test Functions

   183 

   184 // 2nd Thread helper function

   185 static TInt TestThreadFunction(TAny* aPtr)

   186 	{

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

   188 	RDevUsbcClient port = gPort;

   189 	// Now try to duplicate the USB channel handle

   190 	TInt r = port.Duplicate(*other);

   191  	// Wait for 1 second

   192  	User::After(1000000);

   193 	return r;

   194 	}

   195 

   196 

   197 static void OpenChannel()

   198 	{

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

   200 

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

   202 	TInt r = User::LoadLogicalDevice(KUsbLddFilename);

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

   204 

   205 	RDevUsbcClient port1;

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

   207 	r = port1.Open(0);

   208 	test(r == KErrNone);

   209 

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

   211 	r = gPort.Open(0);

   212 	test(r == KErrNone);

   213 

   214 	RDevUsbcClient port2;

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

   216 	r = port2.Open(0);

   217 	test(r == KErrNone);

   218 

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

   220 	port1.Close();

   221 

   222 	RDevUsbcClient port3;

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

   224 	r = port3.Open(0);

   225 	test(r == KErrNone);

   226 

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

   228 	port2.Close();

   229 

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

   231 	port3.Close();

   232 

   233 	// Check for OTG support

   234 	TBuf8<KUsbDescSize_Otg> otg_desc;

   235 	r = gPort.GetOtgDescriptor(otg_desc);

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

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

   238 

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

   240 	// stack will remain disabled forever.

   241 	if (gSupportsOtg)

   242 		{

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

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

   245 		r = User::LoadLogicalDevice(KOtgdiLddFilename);

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

   247 

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

   249 		r = gOTG.Open();

   250 		test(r == KErrNone);

   251 

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

   253 		r = gOTG.StartStacks();

   254 		test(r == KErrNone);

   255 		}

   256 

   257 	// Try duplicating channel handle in a second thread

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

   259 

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

   261 	RThread me;

   262  	TThreadId me_id = me.Id();

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

   264 	// 'special' handle 0xFFFF8001.

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

   266 	RThread test_thread;

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

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

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

   270 	TRequestStatus stat;

   271 	test_thread.Logon(stat);

   272 	test(stat == KRequestPending);

   273 	test_thread.Resume();

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

   275 	User::WaitForRequest(stat);

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

   277 	test(stat == KErrAccessDenied);

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

   279 	test_thread.Close();

   280 

   281 	test.End();

   282 	}

   283 

   284 

   285 static void TestResourceAllocation()

   286 	{

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

   288 

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

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

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

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

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

   294 	if (dma == KErrNone)

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

   296 		test(res);

   297 	else

   298 		test(!res);

   299 

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

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

   302 	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

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

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

   305 	if (db == KErrNone)

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

   307 		test(res);

   308 	else

   309 		test(!res);

   310 

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

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

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

   314 	if (db == KErrNone)

   315 		test(r == KErrNone);

   316 	else

   317 		test(r != KErrNone);

   318 	res = gPort.QueryEndpointResourceUse(EEndpoint1, EUsbcEndpointResourceDoubleBuffering);

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

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

   321 

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

   323 	r = gPort.DeAllocateEndpointResource(EEndpoint1, EUsbcEndpointResourceDMA);

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

   325 	if (dma == KErrNone)

   326 		test(r == KErrNone);

   327 	else

   328 		test(r != KErrNone);

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

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

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

   332 

   333 	test.End();

   334 	}

   335 

   336 

   337 static void SetupInterface()

   338 	{

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

   340 

   341 	// Device caps

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

   343 	TUsbDeviceCaps d_caps;

   344 	TInt r = gPort.DeviceCaps(d_caps);

   345 	test(r == KErrNone);

   346 	TInt n = d_caps().iTotalEndpoints;

   347 

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

   349 	gSupportsHighSpeed = d_caps().iHighSpeed;

   350 

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

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

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

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

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

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

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

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

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

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

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

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

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

   364 				(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_CableDetectWithoutPower) ?

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

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

   367 				(d_caps().iFeatureWord1 & KUsbDevCapsFeatureWord1_EndpointResourceAllocV2) ?

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

   369 

   370 	test(n >= 2);

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

   372 

   373 	// Endpoint caps

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

   375 	TUsbcEndpointData data[KUsbcMaxEndpoints];

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

   377 	r = gPort.EndpointCaps(dataptr);

   378 	test(r == KErrNone);

   379 

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

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

   382 		{

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

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

   385 					caps->iSizes, caps->iTypesAndDir);

   386 		if (caps->iHighBandwidth)

   387 			{

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

   389 			// Must be HS Int or Iso ep

   390 			test(gSupportsHighSpeed);

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

   392 			}

   393 		}

   394 

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

   396 	// Set the active interface

   397 	TUsbcInterfaceInfoBuf ifc;

   398 	TInt ep_found = 0;

   399 	TBool foundBulkIN = EFalse;

   400 	TBool foundBulkOUT = EFalse;

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

   402 		{

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

   404 		const TInt mps = caps->MaxPacketSize();

   405 		if (!foundBulkIN &&

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

   407 			(KUsbEpTypeBulk | KUsbEpDirIn))

   408 			{

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

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

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

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

   413 			foundBulkIN = ETrue;

   414 			if (++ep_found == 2)

   415 				break;

   416 			}

   417 		else if (!foundBulkOUT &&

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

   419 				 (KUsbEpTypeBulk | KUsbEpDirOut))

   420 			{

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

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

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

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

   425 			foundBulkOUT = ETrue;

   426 			if (++ep_found == 2)

   427 				break;

   428 			}

   429 		}

   430 	test(ep_found == 2);

   431 

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

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

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

   435 	ifc().iTotalEndpointsUsed = 2;

   436 	ifc().iClass.iClassNum	  = 0xff;

   437 	ifc().iClass.iSubClassNum = 0xff;

   438 	ifc().iClass.iProtocolNum = 0xff;

   439 	// Set up the interface.

   440 	r = gPort.SetInterface(0, ifc);

   441 	test(r == KErrNone);

   442 

   443 	TInt ifc_no = -1;

   444 	r = gPort.GetAlternateSetting(ifc_no);

   445 	test(r == KErrUsbDeviceNotConfigured);

   446 

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

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

   449 	TestResourceAllocation();

   450 

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

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

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

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

   455 	// when the interface gets deleted.)

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

   457 	r = gPort.PowerUpUdc();

   458 	if (!gSupportsOtg)

   459 		{

   460 		test(r == KErrNone);

   461 		}

   462 	else

   463 		{

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

   465 		}

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

   467 		{

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

   469 		test.End();

   470 		return;

   471 		}

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

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

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

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

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

   477 	r = gPort.DeviceConnectToHost();

   478 	test(r == KErrNone);

   479  	// Suspend thread to let things get stable on the bus.

   480 	test.Printf(_L("Waiting a short moment..."));

   481 	User::After(2000000);

   482 	test.Printf(_L(" done.\n"));

   483 

   484 	// Check the speed of the physical connection (if any).

   485 	gUsingHighSpeed = gPort.CurrentlyUsingHighSpeed();

   486 	if (gUsingHighSpeed)

   487 		{

   488 		test(gSupportsHighSpeed);							// sane?

   489 		test.Printf(_L("---> USB High-speed Testing\n"));

   490 		}

   491 	else

   492 		{

   493 		test.Printf(_L("---> USB Full-speed Testing\n"));

   494 		}

   495 

   496 	// By pulling down the interface/connection and bringing them up again we

   497 	// simulate a starting/stopping of the USB service by a control app.

   498 

   499 	test.Next(_L("Disconnecting from Host"));

   500 	r = gPort.DeviceDisconnectFromHost();

   501 	test(r == KErrNone);

   502 

   503 	test.Next(_L("Releasing interface"));

   504 	r = gPort.ReleaseInterface(0);

   505 	test(r == KErrNone);

   506 

   507 	test.Next(_L("Setting interface"));

   508 	r = gPort.SetInterface(0, ifc);

   509 	test(r == KErrNone);

   510 

   511  	// Suspend thread before connecting again.

   512 	test.Printf(_L("Waiting a short moment..."));

   513 	User::After(1000000);

   514 	test.Printf(_L(" done.\n"));

   515 

   516 	test.Next(_L("Powering up UDC (2)"));

   517 	r = gPort.PowerUpUdc();

   518 	if (!gSupportsOtg)

   519 		{

   520 		test(r == KErrNone);

   521 		}

   522 	else

   523 		{

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

   525 		}

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

   527 		{

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

   529 		test.End();

   530 		return;

   531 		}

   532 

   533 	test.Next(_L("Connecting to Host (2)"));

   534 	r = gPort.DeviceConnectToHost();

   535 	test(r == KErrNone);

   536 	// Suspend thread to let things get stable on the bus.

   537 	User::After(2000000);

   538 

   539 	test.End();

   540 	}

   541 

   542 

   543 static void TestDeviceDescriptor()

   544 	{

   545 	test.Start(_L("Device Descriptor Manipulation"));

   546 

   547 	test.Next(_L("GetDeviceDescriptorSize()"));

   548 	TInt desc_size = 0;

   549 	gPort.GetDeviceDescriptorSize(desc_size);

   550 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Device);

   551 

   552 	test.Next(_L("GetDeviceDescriptor()"));

   553 	TBuf8<KUsbDescSize_Device> descriptor;

   554 	TInt r = gPort.GetDeviceDescriptor(descriptor);

   555 	test(r == KErrNone);

   556 

   557 	test.Next(_L("SetDeviceDescriptor()"));

   558 	// Change the USB spec number to 2.30

   559 	descriptor[KDevDesc_SpecOffset]   = 0x30;

   560 	descriptor[KDevDesc_SpecOffset+1] = 0x02;

   561 	// Change the device vendor ID (VID) to 0x1234

   562 	descriptor[KDevDesc_VendorIdOffset]   = 0x34;			// little endian

   563 	descriptor[KDevDesc_VendorIdOffset+1] = 0x12;

   564 	// Change the device product ID (PID) to 0x1111

   565 	descriptor[KDevDesc_ProductIdOffset]   = 0x11;

   566 	descriptor[KDevDesc_ProductIdOffset+1] = 0x11;

   567 	// Change the device release number to 3.05

   568 	descriptor[KDevDesc_DevReleaseOffset]   = 0x05;

   569 	descriptor[KDevDesc_DevReleaseOffset+1] = 0x03;

   570 	r = gPort.SetDeviceDescriptor(descriptor);

   571 	test(r == KErrNone);

   572 

   573 	test.Next(_L("GetDeviceDescriptor()"));

   574 	TBuf8<KUsbDescSize_Device> descriptor2;

   575 	r = gPort.GetDeviceDescriptor(descriptor2);

   576 	test(r == KErrNone);

   577 

   578 	test.Next(_L("Compare device descriptor with value set"));

   579 	r = descriptor2.Compare(descriptor);

   580 	test(r == KErrNone);

   581 

   582 	if (gUsingHighSpeed)

   583 		{

   584 		// HS only allows one possible packet size.

   585 		test(descriptor[KDevDesc_Ep0SizeOffset] == 64);

   586 		}

   587 

   588 	test.End();

   589 	}

   590 

   591 

   592 static void	TestDeviceQualifierDescriptor()

   593 	{

   594 	test.Start(_L("Device_Qualifier Descriptor Manipulation"));

   595 

   596 	if (!gSupportsHighSpeed)

   597 		{

   598 		test.Printf(_L("*** Not supported - skipping Device_Qualifier descriptor tests\n"));

   599 		test.End();

   600 		return;

   601 		}

   602 

   603 	test.Next(_L("GetDeviceQualifierDescriptor()"));

   604 	TBuf8<KUsbDescSize_DeviceQualifier> descriptor;

   605 	TInt r = gPort.GetDeviceQualifierDescriptor(descriptor);

   606 	test(r == KErrNone);

   607 

   608 	test.Next(_L("SetDeviceQualifierDescriptor()"));

   609 	// Change the USB spec number to 3.00

   610 	descriptor[KDevDesc_SpecOffset]   = 0x00;

   611 	descriptor[KDevDesc_SpecOffset+1] = 0x03;

   612 	// Change the device class, subclass and protocol codes

   613 	descriptor[KDevDesc_DevClassOffset]    = 0xA1;

   614 	descriptor[KDevDesc_DevSubClassOffset] = 0xB2;

   615 	descriptor[KDevDesc_DevProtocolOffset] = 0xC3;

   616 	r = gPort.SetDeviceQualifierDescriptor(descriptor);

   617 	test(r == KErrNone);

   618 

   619 	test.Next(_L("GetDeviceQualifierDescriptor()"));

   620 	TBuf8<KUsbDescSize_DeviceQualifier> descriptor2;

   621 	r = gPort.GetDeviceQualifierDescriptor(descriptor2);

   622 	test(r == KErrNone);

   623 

   624 	test.Next(_L("Compare Device_Qualifier desc with value set"));

   625 	r = descriptor2.Compare(descriptor);

   626 	test(r == 0);

   627 

   628 	if (!gUsingHighSpeed)

   629 		{

   630 		// HS only allows one possible packet size.

   631 		test(descriptor[KDevDesc_Ep0SizeOffset] == 64);

   632 		}

   633 

   634 	test.End();

   635 	}

   636 

   637 

   638 static void TestConfigurationDescriptor()

   639 	{

   640 	test.Start(_L("Configuration Descriptor Manipulation"));

   641 

   642 	test.Next(_L("GetConfigurationDescriptorSize()"));

   643 	TInt desc_size = 0;

   644 	gPort.GetConfigurationDescriptorSize(desc_size);

   645 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Config);

   646 

   647 	test.Next(_L("GetConfigurationDescriptor()"));

   648 	TBuf8<KUsbDescSize_Config> descriptor;

   649 	TInt r = gPort.GetConfigurationDescriptor(descriptor);

   650 	test(r == KErrNone);

   651 

   652 	test.Next(_L("SetConfigurationDescriptor()"));

   653 	// Invert Remote-Wakup support

   654 	descriptor[KConfDesc_AttribOffset] = (descriptor[KConfDesc_AttribOffset] ^ KUsbDevAttr_RemoteWakeup);

   655 	// Change the reported max power to 200mA (2 * 0x64)

   656 	descriptor[KConfDesc_MaxPowerOffset] = 0x64;

   657 	r = gPort.SetConfigurationDescriptor(descriptor);

   658 	test(r == KErrNone);

   659 

   660 	test.Next(_L("GetConfigurationDescriptor()"));

   661 	TBuf8<KUsbDescSize_Config> descriptor2;

   662 	r = gPort.GetConfigurationDescriptor(descriptor2);

   663 	test(r == KErrNone);

   664 

   665 	test.Next(_L("Compare configuration desc with value set"));

   666 	r = descriptor2.Compare(descriptor);

   667 	test(r == KErrNone);

   668 

   669 	test.End();

   670 	}

   671 

   672 

   673 static void	TestOtherSpeedConfigurationDescriptor()

   674 	{

   675 	test.Start(_L("Other_Speed_Configuration Desc Manipulation"));

   676 

   677 	if (!gSupportsHighSpeed)

   678 		{

   679 		test.Printf(_L("*** Not supported - skipping Other_Speed_Configuration desc tests\n"));

   680 		test.End();

   681 		return;

   682 		}

   683 

   684 	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

   685 	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor;

   686 	TInt r = gPort.GetOtherSpeedConfigurationDescriptor(descriptor);

   687 	test(r == KErrNone);

   688 

   689 	test.Next(_L("SetOtherSpeedConfigurationDescriptor()"));

   690 	// Invert Remote-Wakup support

   691 	descriptor[KConfDesc_AttribOffset] = (descriptor[KConfDesc_AttribOffset] ^ KUsbDevAttr_RemoteWakeup);

   692 	// Change the reported max power to 330mA (2 * 0xA5)

   693 	descriptor[KConfDesc_MaxPowerOffset] = 0xA5;

   694 	r = gPort.SetOtherSpeedConfigurationDescriptor(descriptor);

   695 	test(r == KErrNone);

   696 

   697 	test.Next(_L("GetOtherSpeedConfigurationDescriptor()"));

   698 	TBuf8<KUsbDescSize_OtherSpeedConfig> descriptor2;

   699 	r = gPort.GetOtherSpeedConfigurationDescriptor(descriptor2);

   700 	test(r == KErrNone);

   701 

   702 	test.Next(_L("Compare O_S_Config desc with value set"));

   703 	r = descriptor2.Compare(descriptor);

   704 	test(r == KErrNone);

   705 

   706 	test.End();

   707 	}

   708 

   709 

   710 static void TestInterfaceDescriptor()

   711 	{

   712 	test.Start(_L("Interface Descriptor Manipulation"));

   713 

   714 	// First the standard Interface descriptor

   715 

   716 	test.Next(_L("GetInterfaceDescriptorSize()"));

   717 	TInt desc_size = 0;

   718 	TInt r = gPort.GetInterfaceDescriptorSize(0, desc_size);

   719 	test(r == KErrNone);

   720 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Interface);

   721 

   722 	test.Next(_L("GetInterfaceDescriptor()"));

   723 	TBuf8<KUsbDescSize_Interface> descriptor;

   724 	r = gPort.GetInterfaceDescriptor(0, descriptor);

   725 	test(r == KErrNone);

   726 

   727 	test.Next(_L("SetInterfaceDescriptor()"));

   728 	// Change the interface protocol to 0x78(+)

   729 	TUint8 prot = 0x78;

   730 	if (descriptor[KIfcDesc_ProtocolOffset] == prot)

   731 		prot++;

   732 	descriptor[KIfcDesc_ProtocolOffset] = prot;

   733 	r = gPort.SetInterfaceDescriptor(0, descriptor);

   734 	test(r == KErrNone);

   735 

   736 	test.Next(_L("GetInterfaceDescriptor()"));

   737 	TBuf8<KUsbDescSize_Interface> descriptor2;

   738 	r = gPort.GetInterfaceDescriptor(0, descriptor2);

   739 	test(r == KErrNone);

   740 

   741 	test.Next(_L("Compare interface descriptor with value set"));

   742 	r = descriptor2.Compare(descriptor);

   743 	test(r == KErrNone);

   744 

   745 	test.End();

   746 	}

   747 

   748 

   749 static void TestClassSpecificDescriptors()

   750 	{

   751 	test.Start(_L("Class-specific Descriptor Manipulation"));

   752 

   753 	// First a class-specific Interface descriptor

   754 

   755 	test.Next(_L("SetCSInterfaceDescriptorBlock()"));

   756 	// choose arbitrary new descriptor size

   757 	const TInt KUsbDescSize_CS_Interface = KUsbDescSize_Interface + 10;

   758 	TBuf8<KUsbDescSize_CS_Interface> cs_ifc_descriptor;

   759 	cs_ifc_descriptor.FillZ(cs_ifc_descriptor.MaxLength());

   760 	cs_ifc_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Interface;

   761 	cs_ifc_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Interface;

   762 	TInt r = gPort.SetCSInterfaceDescriptorBlock(0, cs_ifc_descriptor);

   763 	test(r == KErrNone);

   764 

   765 	test.Next(_L("GetCSInterfaceDescriptorBlockSize()"));

   766 	TInt desc_size = 0;

   767 	r = gPort.GetCSInterfaceDescriptorBlockSize(0, desc_size);

   768 	test(r == KErrNone);

   769 	test(desc_size == KUsbDescSize_CS_Interface);

   770 

   771 	test.Next(_L("GetCSInterfaceDescriptorBlock()"));

   772 	TBuf8<KUsbDescSize_CS_Interface> descriptor;

   773 	r = gPort.GetCSInterfaceDescriptorBlock(0, descriptor);

   774 	test(r == KErrNone);

   775 

   776 	test.Next(_L("Compare CS ifc descriptor with value set"));

   777 	r = descriptor.Compare(cs_ifc_descriptor);

   778 	test(r == KErrNone);

   779 

   780 	// Next a class-specific Endpoint descriptor

   781 

   782 	test.Next(_L("SetCSEndpointDescriptorBlock()"));

   783 	// choose arbitrary new descriptor size

   784 	const TInt KUsbDescSize_CS_Endpoint = KUsbDescSize_Endpoint + 5;

   785 	TBuf8<KUsbDescSize_CS_Endpoint> cs_ep_descriptor;

   786 	cs_ep_descriptor.FillZ(cs_ep_descriptor.MaxLength());

   787 	cs_ep_descriptor[KUsbDesc_SizeOffset] = KUsbDescSize_CS_Endpoint;

   788 	cs_ep_descriptor[KUsbDesc_TypeOffset] = KUsbDescType_CS_Endpoint;

   789 	r = gPort.SetCSEndpointDescriptorBlock(0, 2, cs_ep_descriptor);

   790 	test(r == KErrNone);

   791 

   792 	test.Next(_L("GetCSEndpointDescriptorBlockSize()"));

   793 	r = gPort.GetCSEndpointDescriptorBlockSize(0, 2, desc_size);

   794 	test(r == KErrNone);

   795 	test(desc_size == KUsbDescSize_CS_Endpoint);

   796 

   797 	test.Next(_L("GetCSEndpointDescriptorBlock()"));

   798 	TBuf8<KUsbDescSize_CS_Endpoint> descriptor2;

   799 	r = gPort.GetCSEndpointDescriptorBlock(0, 2, descriptor2);

   800 	test(r == KErrNone);

   801 

   802 	test.Next(_L("Compare CS ep descriptor with value set"));

   803 	r = descriptor2.Compare(cs_ep_descriptor);

   804 	test(r == KErrNone);

   805 

   806 	test.End();

   807 	}

   808 

   809 

   810 static void TestAlternateInterfaceManipulation()

   811 	{

   812 	test.Start(_L("Alternate Interface Setting Manipulation"));

   813 

   814 	if (!SupportsAlternateInterfaces())

   815 		{

   816 		test.Printf(_L("*** Not supported - skipping alternate interface settings tests\n"));

   817 		test.End();

   818 		return;

   819 		}

   820 

   821 	// Fetch endpoint data (again)

   822 	test.Next(_L("Get endpoint capabilities"));

   823 	TUsbDeviceCaps d_caps;

   824 	TInt r = gPort.DeviceCaps(d_caps);

   825 	test(r == KErrNone);

   826 	const TInt n = d_caps().iTotalEndpoints;

   827 	TUsbcEndpointData data[KUsbcMaxEndpoints];

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

   829 	r = gPort.EndpointCaps(dataptr);

   830 	test(r == KErrNone);

   831 

   832 	// Find ep's for alternate ifc setting

   833 	test.Next(_L("Find suitable endpoints"));

   834 	TInt ep_found = 0;

   835 	TBool foundIsoIN  = EFalse;

   836 	TBool foundIsoOUT = EFalse;

   837 	TBool foundIntIN  = EFalse;

   838 	TUsbcInterfaceInfoBuf ifc;

   839 

   840 	// NB! We cannot assume that any specific device has any given set of

   841 	// capabilities, so whilst we try and set an assortment of endpoint types

   842 	// we may not get what we want.

   843 

   844 	// Also, note that the endpoint[] array in the interface descriptor

   845 	// must be filled from ep[0]...ep[n-1].

   846 

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

   848 		{

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

   850 		const TInt mps = caps->MaxPacketSize();

   851 		if (!foundIsoIN &&

   852 			(caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpDirIn)) ==

   853 			(KUsbEpTypeIsochronous | KUsbEpDirIn))

   854 			{

   855 			// This is going to be our Iso TX (IN) endpoint

   856 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeIsochronous;

   857 			ifc().iEndpointData[ep_found].iDir  = KUsbEpDirIn;

   858 			ifc().iEndpointData[ep_found].iSize = mps;

   859 			ifc().iEndpointData[ep_found].iInterval = 0x01;	// 2^(bInterval-1)ms, bInterval must be [1..16]

   860 			ifc().iEndpointData[ep_found].iInterval_Hs = 0x01; // same as for FS

   861 			test.Printf(_L("ISO  IN  size = %4d (ep %d)\n"), mps, ep_found + 1);

   862 			foundIsoIN = ETrue;

   863 			if (++ep_found == 3)

   864 				break;

   865 			}

   866 		else if (!foundIsoOUT &&

   867 				 (caps->iTypesAndDir & (KUsbEpTypeIsochronous | KUsbEpDirOut)) ==

   868 				 (KUsbEpTypeIsochronous | KUsbEpDirOut))

   869 			{

   870 			// This is going to be our Iso RX (OUT) endpoint

   871 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeIsochronous;

   872 			ifc().iEndpointData[ep_found].iDir  = KUsbEpDirOut;

   873 			ifc().iEndpointData[ep_found].iSize = mps;

   874 			ifc().iEndpointData[ep_found].iInterval = 0x01;	// 2^(bInterval-1)ms, bInterval must be [1..16]

   875 			test.Printf(_L("ISO  OUT size = %4d (ep %d)\n"), mps, ep_found + 1);

   876 			foundIsoOUT = ETrue;

   877 			if (++ep_found == 3)

   878 				break;

   879 			}

   880 		else if (!foundIntIN &&

   881 				 (caps->iTypesAndDir & (KUsbEpTypeInterrupt | KUsbEpDirIn)) ==

   882 				 (KUsbEpTypeInterrupt | KUsbEpDirIn))

   883 			{

   884 			// This is going to be our Interrupt TX (IN) endpoint

   885 			ifc().iEndpointData[ep_found].iType  = KUsbEpTypeInterrupt;

   886 			ifc().iEndpointData[ep_found].iDir   = KUsbEpDirIn;

   887 			ifc().iEndpointData[ep_found].iSize  = mps;

   888 			ifc().iEndpointData[ep_found].iInterval = 10;	// interval = 10ms, valid range [1..255]

   889 			ifc().iEndpointData[ep_found].iInterval_Hs = 4;	// interval = 2^(bInterval-1)ms = 8ms

   890 			ifc().iEndpointData[ep_found].iExtra    = 2;	// 2 extra bytes for Audio Class EP descriptor

   891 			test.Printf(_L("INT  IN  size = %4d (ep %d)\n"), mps, ep_found + 1);

   892 			foundIntIN = ETrue;

   893 			INT_IN_ep = ep_found + 1;

   894 			if (++ep_found == 3)

   895 				break;

   896 			}

   897 		}

   898 

   899 	// Let's try to add some more Bulk endpoints up to the max # of 5.

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

   901 		{

   902 		TUsbcEndpointCaps& caps = data[i].iCaps;

   903 		const TUint mps = caps.MaxPacketSize();

   904 		if (caps.iTypesAndDir & KUsbEpTypeBulk)

   905 			{

   906 			const TUint dir = (caps.iTypesAndDir & KUsbEpDirIn) ? KUsbEpDirIn : KUsbEpDirOut;

   907 			ifc().iEndpointData[ep_found].iType = KUsbEpTypeBulk;

   908 			ifc().iEndpointData[ep_found].iDir = dir;

   909 			if (gUsingHighSpeed)

   910 				{

   911 				test.Printf(_L("Checking if correct Bulk packet size is reported in HS case\n"));

   912 				test(mps == KUsbEpSize512);					// sane?

   913 				}

   914 			// The PSL should in any case also offer the 'legacy' FS size:

   915 			test(caps.iSizes & KUsbEpSize64);

   916 			ifc().iEndpointData[ep_found].iSize = mps;

   917 			test.Printf(_L("BULK %s size = %4d (ep %d)\n"),

   918 						dir == KUsbEpDirIn ? _S("IN ") : _S("OUT"), mps, ep_found + 1);

   919 			if (++ep_found == 5)

   920 				break;

   921 			}

   922 		}

   923 

   924 	test.Printf(_L("Total: %d endpoints found for the alt. ifc setting\n"), ep_found);

   925 	if (ep_found < 3)

   926 		{

   927 		test.Printf(_L("(3 endpoints are at least required. Skipping test...)\n"));

   928 		test.End();

   929 		return;

   930 		}

   931 

   932 	if (!foundIsoIN && !foundIsoOUT)

   933 		{

   934 		test.Printf(_L("(No Isochronous endpoints found)\n"));

   935 		}

   936 

   937 	if (!foundIntIN)

   938 		{

   939 		test.Printf(_L("(No Interrupt endpoint found)\n"));

   940 		test.Printf(_L("Adjusting endpoint size for later test\n"));

   941 		// We want to make sure that at least one descriptor has the 2 extra bytes.

   942 		// It doesn't matter that this ep could be a Bulk one, or that the 2 Iso ep's might be missing -

   943 		// we just want to test some functionality and we're not going to use this interface in earnest.

   944 		ifc().iEndpointData[2].iExtra = 2;					// 2 extra bytes for Audio Class Ep descriptor

   945 		INT_IN_ep = 3;										// pretend it's an INT ep

   946 		}

   947 

   948 	test.Next(_L("Create alternate interface setting"));

   949 	_LIT16(string, "T_USBAPI Test Interface (Setting 1: Audio)");

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

   951 	ifc().iTotalEndpointsUsed = ep_found;

   952 	ifc().iClass.iClassNum	  = KUsbAudioInterfaceClassCode;

   953 	ifc().iClass.iSubClassNum = KUsbAudioInterfaceSubclassCode_Audiostreaming;

   954 	ifc().iClass.iProtocolNum = KUsbAudioInterfaceProtocolCode_Pr_Protocol_Undefined;

   955 	r = gPort.SetInterface(1, ifc);

   956 	test(r == KErrNone);

   957 

   958 	test.Next(_L("Set alternate setting number to 8"));

   959 	TBuf8<KUsbDescSize_Interface> descriptor;

   960 	r = gPort.GetInterfaceDescriptor(1, descriptor);

   961 	test(r == KErrNone);

   962 	descriptor[KIfcDesc_SettingOffset] = 8;

   963 	r = gPort.SetInterfaceDescriptor(1, descriptor);

   964 	test(r != KErrNone);

   965 

   966 	test.Next(_L("Change ifc # in def setting whith alt ifcs"));

   967 	r = gPort.GetInterfaceDescriptor(0, descriptor);

   968 	test(r == KErrNone);

   969 	descriptor[KIfcDesc_SettingOffset] = 8;

   970 	r = gPort.SetInterfaceDescriptor(0, descriptor);

   971 	test(r != KErrNone);

   972 

   973 	test.Next(_L("Change the ifc # in default setting to 8"));

   974 	r = gPort.ReleaseInterface(1);

   975 	test(r == KErrNone);

   976 	r = gPort.SetInterfaceDescriptor(0, descriptor);

   977 	test(r == KErrNone);

   978 

   979 	test.Next(_L("Create new setting - this should also get #8"));

   980 	r = gPort.SetInterface(1, ifc);

   981 	test(r == KErrNone);

   982 	r = gPort.GetInterfaceDescriptor(1, descriptor);

   983 	test(r == KErrNone);

   984 	test(descriptor[KIfcDesc_SettingOffset] == 8);

   985 

   986 	test.Next(_L("Change the ifc # in default setting to 0"));

   987 	r = gPort.ReleaseInterface(1);

   988 	test(r == KErrNone);

   989 	r = gPort.GetInterfaceDescriptor(0, descriptor);

   990 	test(r == KErrNone);

   991 	descriptor[KIfcDesc_SettingOffset] = 0;

   992 	r = gPort.SetInterfaceDescriptor(0, descriptor);

   993 	test(r == KErrNone);

   994 

   995 	test.Next(_L("Create new setting - this should also get #0"));

   996 	r = gPort.SetInterface(1, ifc);

   997 	test(r == KErrNone);

   998 	r = gPort.GetInterfaceDescriptor(1, descriptor);

   999 	test(r == KErrNone);

  1000 	test(descriptor[KIfcDesc_SettingOffset] == 0);

  1001 

  1002 	test.End();

  1003 	}

  1004 

  1005 

  1006 static void TestEndpointDescriptor()

  1007 	{

  1008 	test.Start(_L("Endpoint Descriptor Manipulation"));

  1009 

  1010 	test.Next(_L("GetEndpointDescriptorSize(1)"));

  1011 	TInt epNumber = 1;

  1012 	TInt desc_size = 0;

  1013 	TInt r = gPort.GetEndpointDescriptorSize(0, epNumber, desc_size);

  1014 	test(r == KErrNone);

  1015 	test(static_cast<TUint>(desc_size) == KUsbDescSize_Endpoint);

  1016 

  1017 	test.Next(_L("GetEndpointDescriptor(1)"));

  1018 	TBuf8<KUsbDescSize_Endpoint> descriptor;

  1019 	r = gPort.GetEndpointDescriptor(0, epNumber, descriptor);

  1020 	test(r == KErrNone);

  1021 

  1022 	test.Next(_L("SetEndpointDescriptor(1)"));

  1023 	// Change the endpoint poll interval

  1024 	TUint8 ival = 0x66;

  1025 	if (descriptor[KEpDesc_IntervalOffset] == ival)

  1026 		ival++;

  1027 	descriptor[KEpDesc_IntervalOffset] = ival;

  1028 	r = gPort.SetEndpointDescriptor(0, epNumber, descriptor);

  1029 	test(r == KErrNone);

  1030 

  1031 	test.Next(_L("GetEndpointDescriptor(1)"));

  1032 	TBuf8<KUsbDescSize_Endpoint> descriptor2;

  1033 	r = gPort.GetEndpointDescriptor(0, epNumber, descriptor2);

  1034 	test(r == KErrNone);

  1035 

  1036 	test.Next(_L("Compare endpoint descriptor with value set"));

  1037 	r = descriptor2.Compare(descriptor);

  1038 	test(r == KErrNone);

  1039 

  1040 	test.Next(_L("Check endpoint max packet size"));

  1041 	const TUint16 ep_size = EpSize(descriptor[KEpDesc_PacketSizeOffset],

  1042 								   descriptor[KEpDesc_PacketSizeOffset+1]);

  1043 	test.Printf(_L(" Size: %d\n"), ep_size);

  1044 	if (gUsingHighSpeed)

  1045 		{

  1046 		// HS Bulk ep can only have one possible packet size.

  1047 		test(ep_size == 512);

  1048 		}

  1049 	else

  1050 		{

  1051 		// FS Bulk ep cannot be larger than 64 bytes.

  1052 		test(ep_size <= 64);

  1053 		}

  1054 

  1055 	test.End();

  1056 	}

  1057 

  1058 

  1059 static void TestExtendedEndpointDescriptor()

  1060 	{

  1061 	test.Start(_L("Extended Endpoint Descriptor Manipulation"));

  1062 

  1063 	if (!SupportsAlternateInterfaces())

  1064 		{

  1065 		test.Printf(_L("*** Not supported - skipping Extended Endpoint descriptor tests\n"));

  1066 		test.End();

  1067 		return;

  1068 		}

  1069 

  1070 	// Extended Endpoint Descriptor manipulation (Audio class endpoint)

  1071 

  1072 	test.Next(_L("GetEndpointDescriptorSize()"));

  1073 	TInt epNumber = INT_IN_ep;

  1074 	TInt desc_size = 0;

  1075 	TInt r = gPort.GetEndpointDescriptorSize(1, epNumber, desc_size);

  1076 	test(r == KErrNone);

  1077 	test(static_cast<TUint>(desc_size) == KUsbDescSize_AudioEndpoint);

  1078 

  1079 	test.Next(_L("GetEndpointDescriptor()"));

  1080 	TBuf8<KUsbDescSize_AudioEndpoint> descriptor;

  1081 	r = gPort.GetEndpointDescriptor(1, epNumber, descriptor);

  1082 	test(r == KErrNone);

  1083 

  1084 	test.Next(_L("SetEndpointDescriptor()"));

  1085 	// Change the Audio Endpoint bSynchAddress field

  1086 	TUint8 addr = 0x85;										// bogus address

  1087 	if (descriptor[KEpDesc_SynchAddressOffset] == addr)

  1088 		addr++;

  1089 	descriptor[KEpDesc_SynchAddressOffset] = addr;

  1090 	r = gPort.SetEndpointDescriptor(1, epNumber, descriptor);

  1091 	test(r == KErrNone);

  1092 

  1093 	test.Next(_L("GetEndpointDescriptor()"));

  1094 	TBuf8<KUsbDescSize_AudioEndpoint> descriptor2;

  1095 	r = gPort.GetEndpointDescriptor(1, epNumber, descriptor2);

  1096 	test(r == KErrNone);

  1097 

  1098 	test.Next(_L("Compare endpoint descriptor with value set"));

  1099 	r = descriptor2.Compare(descriptor);

  1100 	test(r == KErrNone);

  1101 

  1102 	test.Next(_L("Check endpoint max packet size"));

  1103 	const TUint16 ep_size = EpSize(descriptor[KEpDesc_PacketSizeOffset],

  1104 								   descriptor[KEpDesc_PacketSizeOffset+1]);

  1105 	if (gUsingHighSpeed)

  1106 		{

  1107 		// HS Interrupt ep.

  1108 		test(ep_size <= 1024);

  1109 		}

  1110 	else

  1111 		{

  1112 		// FS Interrupt ep cannot be larger than 64 bytes.

  1113 		test(ep_size <= 64);

  1114 		}

  1115 

  1116 	test.End();

  1117 	}

  1118 

  1119 

  1120 static void TestStandardStringDescriptors()

  1121 	{

  1122 	test.Start(_L("String Descriptor Manipulation"));

  1123 

  1124 	//

  1125 	// --- LANGID code

  1126 	//

  1127 

  1128 	test.Next(_L("GetStringDescriptorLangId()"));

  1129 	TUint16 rd_langid_orig;

  1130 	TInt r = gPort.GetStringDescriptorLangId(rd_langid_orig);

  1131 	test(r == KErrNone);

  1132 	test.Printf(_L("Original LANGID code: 0x%04X\n"), rd_langid_orig);

  1133 

  1134 	test.Next(_L("SetStringDescriptorLangId()"));