kerneltest/e32test/usb/t_usb_device/src/activecontrol.cpp
changeset 270 ea2cef07f9fe
parent 253 d37db4dcc88d
equal deleted inserted replaced
255:d45b74d3fb20 270:ea2cef07f9fe
    22 #include "usblib.h"											// Helpers
    22 #include "usblib.h"											// Helpers
    23 #include "config.h"
    23 #include "config.h"
    24 #include "activecontrol.h"
    24 #include "activecontrol.h"
    25 #include "apitests.h"
    25 #include "apitests.h"
    26 #include "activerw.h"
    26 #include "activerw.h"
       
    27 #include "d32otgdi.h"
    27 #ifdef USB_SC
    28 #ifdef USB_SC
    28 #include "tranhandleserver.h"
    29 #include "tranhandleserver.h"
    29 #endif
    30 #endif
    30 
    31 
    31 #include "OstTraceDefinitions.h"
    32 #include "OstTraceDefinitions.h"
    34 #endif
    35 #endif
    35 
    36 
    36 
    37 
    37 void StartMassStorage(RDEVCLIENT* aPort);
    38 void StartMassStorage(RDEVCLIENT* aPort);
    38 void StopMassStorage(RDEVCLIENT* aPort);
    39 void StopMassStorage(RDEVCLIENT* aPort);
       
    40 void OpenStackIfOtg();
       
    41 void CloseStackIfOtg();
       
    42 
       
    43 _LIT(KOtgdiLddFilename, "otgdi");
       
    44 static TBool gSupportsOtg;
       
    45 static RUsbOtgDriver gOtgPort;
    39 
    46 
    40 enum Ep0Requests
    47 enum Ep0Requests
    41 	{
    48 	{
    42 	EStop = 0x1,
    49 	EStop = 0x1,
    43 	EVersion = 0x10,
    50 	EVersion = 0x10,
   285 					#endif
   292 					#endif
   286 					}
   293 					}
   287 				}
   294 				}
   288 			}
   295 			}
   289 
   296 
       
   297 		// Check for OTG support
       
   298 		TBuf8<KUsbDescSize_Otg> otg_desc;
       
   299 		r = iPort[0].GetOtgDescriptor(otg_desc);
       
   300 		if (!(r == KErrNotSupported || r == KErrNone))
       
   301 			{
       
   302 			OstTrace1(TRACE_NORMAL, CACTIVECONTROL_CONSTRUCTL_DUP08, "Error %d while fetching OTG descriptor", r);
       
   303 			User::Leave(-1);
       
   304 			return;
       
   305 			}
       
   306 		gSupportsOtg = (r != KErrNotSupported) ? ETrue : EFalse;
       
   307 
       
   308 		OpenStackIfOtg();
       
   309 		
   290 		iTotalChannels += lddPtr->iNumChannels;
   310 		iTotalChannels += lddPtr->iNumChannels;
   291 		nextPort += lddPtr->iNumChannels;
   311 		nextPort += lddPtr->iNumChannels;
   292 		lddPtr = lddPtr->iPtrNext;
   312 		lddPtr = lddPtr->iPtrNext;
   293 		}
   313 		}
   294 
   314 
  1028 
  1048 
  1029 					if (value && firstBulkOutEndpoint > 0)
  1049 					if (value && firstBulkOutEndpoint > 0)
  1030 						{
  1050 						{
  1031 						PrintHostLog();
  1051 						PrintHostLog();
  1032 						}
  1052 						}
  1033 
  1053 						
       
  1054 					CloseStackIfOtg();
       
  1055 					
  1034 					for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)
  1056 					for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)
  1035 						{
  1057 						{
  1036 						// base class cancel -> calls our DoCancel
  1058 						// base class cancel -> calls our DoCancel
  1037 						delete iDeviceStateNotifier[portNumber];
  1059 						delete iDeviceStateNotifier[portNumber];
  1038 						delete iStallNotifier[portNumber];
  1060 						delete iStallNotifier[portNumber];
  1370 					// send this now as the port will be disconnected
  1392 					// send this now as the port will be disconnected
  1371 					sendStatus = EFalse;
  1393 					sendStatus = EFalse;
  1372 					r = iPort[0].SendEp0StatusPacket();
  1394 					r = iPort[0].SendEp0StatusPacket();
  1373 					test_KErrNone(r);
  1395 					test_KErrNone(r);
  1374 
  1396 
       
  1397 					CloseStackIfOtg();
       
  1398 					
  1375 					for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)
  1399 					for (TInt portNumber = 0; portNumber < iTotalChannels; portNumber++)
  1376 						{
  1400 						{
  1377 						delete iDeviceStateNotifier[portNumber];
  1401 						delete iDeviceStateNotifier[portNumber];
  1378 						delete iStallNotifier[portNumber];
  1402 						delete iStallNotifier[portNumber];
  1379 						if (portNumber == 0)
  1403 						if (portNumber == 0)
  1413 					    }
  1437 					    }
  1414 
  1438 
  1415 					SetupDescriptors(iLddPtr, &iPort[0],value);
  1439 					SetupDescriptors(iLddPtr, &iPort[0],value);
  1416 					StartMassStorage(&iPort[0]);
  1440 					StartMassStorage(&iPort[0]);
  1417 
  1441 
       
  1442 					OpenStackIfOtg();
       
  1443 					
  1418 					test.Next (_L("Enumeration..."));
  1444 					test.Next (_L("Enumeration..."));
  1419 					r = ReEnumerate();
  1445 					r = ReEnumerate();
  1420 					test_KErrNone(r);
  1446 					test_KErrNone(r);
  1421 
  1447 
  1422 
  1448 
  2358 	test.End();
  2384 	test.End();
  2359 	RequestEp0ControlPacket();
  2385 	RequestEp0ControlPacket();
  2360 	}
  2386 	}
  2361 
  2387 
  2362 #endif
  2388 #endif
       
  2389 
       
  2390 void OpenStackIfOtg()
       
  2391 	{
       
  2392 	// On an OTG device we have to start the OTG driver, otherwise the Client
       
  2393 	// stack will remain disabled forever.
       
  2394 	if (gSupportsOtg)
       
  2395 		{
       
  2396 		test.Start(_L("Running on OTG device: loading OTG driver\n"));
       
  2397 		test.Next(_L("Load OTG LDD"));
       
  2398 		TInt r = User::LoadLogicalDevice(KOtgdiLddFilename);
       
  2399 		test((r == KErrNone) || (r == KErrAlreadyExists));
       
  2400 
       
  2401 		test.Next(_L("Open OTG channel"));
       
  2402 		r = gOtgPort.Open();
       
  2403 		test(r == KErrNone);
       
  2404 
       
  2405 		test.Next(_L("Start OTG stack"));
       
  2406 		r = gOtgPort.StartStacks();
       
  2407 		test(r == KErrNone);
       
  2408 		test.End();
       
  2409 		}
       
  2410 	}
       
  2411 
       
  2412 void CloseStackIfOtg()
       
  2413 	{
       
  2414 	if (gSupportsOtg)
       
  2415 		{
       
  2416 		test.Start(_L("Close OTG stack\n"));
       
  2417 		test.Next(_L("Stop OTG stack"));
       
  2418 		gOtgPort.StopStacks();
       
  2419 		test.Next(_L("Close OTG Channel"));
       
  2420 		gOtgPort.Close();
       
  2421 		test.Next(_L("Free OTG LDD"));
       
  2422 		TInt r = User::FreeLogicalDevice(RUsbOtgDriver::Name());
       
  2423 		test(r == KErrNone);
       
  2424 		test.End();
       
  2425 		}
       
  2426 	}
       
  2427 	
  2363 // -eof-
  2428 // -eof-