UsbTest.cpp@ 76553

Last change on this file since 76553 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 23.5 KB

Line
1	/* $Id: UsbTest.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* UsbTest - User frontend for the Linux usbtest USB test and benchmarking module.
4	* Integrates with our test framework for nice outputs.
5	*/
6
7	/*
8	* Copyright (C) 2014-2019 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* The contents of this file may alternatively be used under the terms
19	* of the Common Development and Distribution License Version 1.0
20	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
21	* VirtualBox OSE distribution, in which case the provisions of the
22	* CDDL are applicable instead of those of the GPL.
23	*
24	* You may elect to license modified versions of this file under the
25	* terms and conditions of either the GPL or the CDDL or both.
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <iprt/dir.h>
33	#include <iprt/err.h>
34	#include <iprt/file.h>
35	#include <iprt/getopt.h>
36	#include <iprt/path.h>
37	#include <iprt/param.h>
38	#include <iprt/process.h>
39	#include <iprt/stream.h>
40	#include <iprt/string.h>
41	#include <iprt/test.h>
42
43	#include <iprt/linux/sysfs.h>
44
45	#include <unistd.h>
46	#include <errno.h>
47	#include <limits.h>
48
49	#include <sys/types.h>
50	#include <sys/stat.h>
51	#include <fcntl.h>
52
53	#include <sys/ioctl.h>
54	#include <linux/usbdevice_fs.h>
55
56
57	/*********************************************************************************************************************************
58	* Defined Constants And Macros *
59	*********************************************************************************************************************************/
60
61
62	/*********************************************************************************************************************************
63	* Structures and Typedefs *
64	*********************************************************************************************************************************/
65
66	/**
67	* USB test request data.
68	* There is no public header with this information so we define it ourself here.
69	*/
70	typedef struct USBTESTPARMS
71	{
72	/** Specifies the test to run. */
73	uint32_t idxTest;
74	/** How many iterations the test should be executed. */
75	uint32_t cIterations;
76	/** Size of the data packets. */
77	uint32_t cbData;
78	/** Size of */
79	uint32_t cbVariation;
80	/** Length of the S/G list for the test. */
81	uint32_t cSgLength;
82	/** Returned time data after completing the test. */
83	struct timeval TimeTest;
84	} USBTESTPARAMS;
85	/** Pointer to a test parameter structure. */
86	typedef USBTESTPARAMS *PUSBTESTPARAMS;
87
88	/**
89	* USB device descriptor. Used to search for the test device based
90	* on the vendor and product id.
91	*/
92	#pragma pack(1)
93	typedef struct USBDEVDESC
94	{
95	uint8_t bLength;
96	uint8_t bDescriptorType;
97	uint16_t bcdUSB;
98	uint8_t bDeviceClass;
99	uint8_t bDeviceSubClass;
100	uint8_t bDeviceProtocol;
101	uint8_t bMaxPacketSize0;
102	uint16_t idVendor;
103	uint16_t idProduct;
104	uint16_t bcdDevice;
105	uint8_t iManufacturer;
106	uint8_t iProduct;
107	uint8_t iSerialNumber;
108	uint8_t bNumConfigurations;
109	} USBDEVDESC;
110	#pragma pack()
111
112	#define USBTEST_REQUEST _IOWR('U', 100, USBTESTPARMS)
113
114	/**
115	* Callback to set up the test parameters for a specific test.
116	*
117	* @returns IPRT status code.
118	* @retval VINF_SUCCESS if setting the parameters up succeeded. Any other error code
119	* otherwise indicating the kind of error.
120	* @param idxTest The test index.
121	* @param pszTest Test name.
122	* @param pParams The USB test parameters to set up.
123	*/
124	typedef DECLCALLBACK(int) FNUSBTESTPARAMSSETUP(unsigned idxTest, const char *pszTest, PUSBTESTPARAMS pParams);
125	/** Pointer to a USB test parameters setup callback. */
126	typedef FNUSBTESTPARAMSSETUP *PFNUSBTESTPARAMSSETUP;
127
128	/**
129	* USB test descriptor.
130	*/
131	typedef struct USBTESTDESC
132	{
133	/** (Sort of) Descriptive test name. */
134	const char *pszName;
135	/** Flag whether the test is excluded. */
136	bool fExcluded;
137	/** The parameter setup callback. */
138	PFNUSBTESTPARAMSSETUP pfnParamsSetup;
139	} USBTESTDESC;
140	/** Pointer a USB test descriptor. */
141	typedef USBTESTDESC *PUSBTESTDESC;
142
143	/**
144	* USB speed values.
145	*/
146	typedef enum USBTESTSPEED
147	{
148	USBTESTSPEED_ANY = 0,
149	USBTESTSPEED_UNKNOWN,
150	USBTESTSPEED_LOW,
151	USBTESTSPEED_FULL,
152	USBTESTSPEED_HIGH,
153	USBTESTSPEED_SUPER
154	} USBTESTSPEED;
155
156
157	/*********************************************************************************************************************************
158	* Global Variables *
159	*********************************************************************************************************************************/
160
161	/** Some forward method declarations. */
162	static DECLCALLBACK(int) usbTestParamsSetupReadWrite(unsigned idxTest, const char *pszTest, PUSBTESTPARAMS pParams);
163	static DECLCALLBACK(int) usbTestParamsSetupControlWrites(unsigned idxTest, const char *pszTest, PUSBTESTPARAMS pParams);
164
165	/** Command line parameters */
166	static const RTGETOPTDEF g_aCmdOptions[] =
167	{
168	{"--device", 'd', RTGETOPT_REQ_STRING },
169	{"--help", 'h', RTGETOPT_REQ_NOTHING},
170	{"--exclude", 'e', RTGETOPT_REQ_UINT32},
171	{"--exclude-all", 'a', RTGETOPT_REQ_NOTHING},
172	{"--include", 'i', RTGETOPT_REQ_UINT32},
173	{"--expected-speed", 's', RTGETOPT_REQ_STRING }
174	};
175
176	static USBTESTDESC g_aTests[] =
177	{
178	/* pszTest fExcluded pfnParamsSetup */
179	{"NOP", false, usbTestParamsSetupReadWrite},
180	{"Non-queued Bulk write", false, usbTestParamsSetupReadWrite},
181	{"Non-queued Bulk read", false, usbTestParamsSetupReadWrite},
182	{"Non-queued Bulk write variabe size", false, usbTestParamsSetupReadWrite},
183	{"Non-queued Bulk read variabe size", false, usbTestParamsSetupReadWrite},
184	{"Queued Bulk write", false, usbTestParamsSetupReadWrite},
185	{"Queued Bulk read", false, usbTestParamsSetupReadWrite},
186	{"Queued Bulk write variabe size", false, usbTestParamsSetupReadWrite},
187	{"Queued Bulk read variabe size", false, usbTestParamsSetupReadWrite},
188	{"Chapter 9 Control Test", false, usbTestParamsSetupReadWrite},
189	{"Queued control messaging", false, usbTestParamsSetupReadWrite},
190	{"Unlink reads", false, usbTestParamsSetupReadWrite},
191	{"Unlink writes", false, usbTestParamsSetupReadWrite},
192	{"Set/Clear halts", false, usbTestParamsSetupReadWrite},
193	{"Control writes", false, usbTestParamsSetupControlWrites},
194	{"Isochronous write", false, usbTestParamsSetupReadWrite},
195	{"Isochronous read", false, usbTestParamsSetupReadWrite},
196	{"Bulk write unaligned (DMA)", false, usbTestParamsSetupReadWrite},
197	{"Bulk read unaligned (DMA)", false, usbTestParamsSetupReadWrite},
198	{"Bulk write unaligned (no DMA)", false, usbTestParamsSetupReadWrite},
199	{"Bulk read unaligned (no DMA)", false, usbTestParamsSetupReadWrite},
200	{"Control writes unaligned", false, usbTestParamsSetupControlWrites},
201	{"Isochronous write unaligned", false, usbTestParamsSetupReadWrite},
202	{"Isochronous read unaligned", false, usbTestParamsSetupReadWrite},
203	{"Unlink queued Bulk", false, usbTestParamsSetupReadWrite}
204	};
205
206	/** The test handle. */
207	static RTTEST g_hTest;
208	/** The expected device speed. */
209	static USBTESTSPEED g_enmSpeed = USBTESTSPEED_ANY;
210
211	/**
212	* Setup callback for basic read/write (bulk, isochronous) tests.
213	*
214	* @copydoc FNUSBTESTPARAMSSETUP
215	*/
216	static DECLCALLBACK(int) usbTestParamsSetupReadWrite(unsigned idxTest, const char *pszTest, PUSBTESTPARAMS pParams)
217	{
218	NOREF(idxTest);
219	NOREF(pszTest);
220
221	pParams->cIterations = 1000;
222	pParams->cbData = 512;
223	pParams->cbVariation = 512;
224	pParams->cSgLength = 32;
225
226	return VINF_SUCCESS;
227	}
228
229	/**
230	* Setup callback for the control writes test.
231	*
232	* @copydoc FNUSBTESTPARAMSSETUP
233	*/
234	static DECLCALLBACK(int) usbTestParamsSetupControlWrites(unsigned idxTest, const char *pszTest, PUSBTESTPARAMS pParams)
235	{
236	NOREF(idxTest);
237	NOREF(pszTest);
238
239	pParams->cIterations = 1000;
240	pParams->cbData = 512;
241	/*
242	* Must be smaller than cbData or the parameter check in the usbtest module fails,
243	* no idea yet why it must be this.
244	*/
245	pParams->cbVariation = 256;
246	pParams->cSgLength = 32;
247
248	return VINF_SUCCESS;
249	}
250
251	/**
252	* Shows tool usage text.
253	*/
254	static void usbTestUsage(PRTSTREAM pStrm)
255	{
256	char szExec[RTPATH_MAX];
257	RTStrmPrintf(pStrm, "usage: %s [options]\n",
258	RTPathFilename(RTProcGetExecutablePath(szExec, sizeof(szExec))));
259	RTStrmPrintf(pStrm, "\n");
260	RTStrmPrintf(pStrm, "options: \n");
261
262
263	for (unsigned i = 0; i < RT_ELEMENTS(g_aCmdOptions); i++)
264	{
265	const char *pszHelp;
266	switch (g_aCmdOptions[i].iShort)
267	{
268	case 'h':
269	pszHelp = "Displays this help and exit";
270	break;
271	case 'd':
272	pszHelp = "Use the specified test device";
273	break;
274	case 'e':
275	pszHelp = "Exclude the given test id from the list";
276	break;
277	case 'a':
278	pszHelp = "Exclude all tests from the list (useful to enable single tests later with --include)";
279	break;
280	case 'i':
281	pszHelp = "Include the given test id in the list";
282	break;
283	case 's':
284	pszHelp = "The device speed to expect";
285	break;
286	default:
287	pszHelp = "Option undocumented";
288	break;
289	}
290	char szOpt[256];
291	RTStrPrintf(szOpt, sizeof(szOpt), "%s, -%c", g_aCmdOptions[i].pszLong, g_aCmdOptions[i].iShort);
292	RTStrmPrintf(pStrm, " %-30s%s\n", szOpt, pszHelp);
293	}
294	}
295
296	/**
297	* Searches for a USB test device and returns the bus and device ID and the device speed.
298	*/
299	static int usbTestDeviceQueryBusAndDevId(uint16_t pu16BusId, uint16_t pu16DevId, USBTESTSPEED *penmSpeed)
300	{
301	bool fFound = false;
302
303	#define USBTEST_USB_DEV_SYSFS "/sys/bus/usb/devices/"
304
305	RTDIR hDirUsb = NULL;
306	int rc = RTDirOpen(&hDirUsb, USBTEST_USB_DEV_SYSFS);
307	if (RT_SUCCESS(rc))
308	{
309	do
310	{
311	RTDIRENTRY DirUsbBus;
312	rc = RTDirRead(hDirUsb, &DirUsbBus, NULL);
313	if ( RT_SUCCESS(rc)
314	&& RTStrNCmp(DirUsbBus.szName, "usb", 3)
315	&& RTLinuxSysFsExists(USBTEST_USB_DEV_SYSFS "%s/idVendor", DirUsbBus.szName))
316	{
317	int64_t idVendor = 0;
318	int64_t idProduct = 0;
319	int64_t iBusId = 0;
320	int64_t iDevId = 0;
321	char aszSpeed[20];
322
323	rc = RTLinuxSysFsReadIntFile(16, &idVendor, USBTEST_USB_DEV_SYSFS "%s/idVendor", DirUsbBus.szName);
324	if (RT_SUCCESS(rc))
325	rc = RTLinuxSysFsReadIntFile(16, &idProduct, USBTEST_USB_DEV_SYSFS "%s/idProduct", DirUsbBus.szName);
326	if (RT_SUCCESS(rc))
327	rc = RTLinuxSysFsReadIntFile(16, &iBusId, USBTEST_USB_DEV_SYSFS "%s/busnum", DirUsbBus.szName);
328	if (RT_SUCCESS(rc))
329	rc = RTLinuxSysFsReadIntFile(16, &iDevId, USBTEST_USB_DEV_SYSFS "%s/devnum", DirUsbBus.szName);
330	if (RT_SUCCESS(rc))
331	rc = RTLinuxSysFsReadStrFile(&aszSpeed[0], sizeof(aszSpeed), NULL, USBTEST_USB_DEV_SYSFS "%s/speed", DirUsbBus.szName);
332
333	if ( RT_SUCCESS(rc)
334	&& idVendor == 0x0525
335	&& idProduct == 0xa4a0)
336	{
337	if (penmSpeed)
338	{
339	/* Parse the speed. */
340	if (!RTStrCmp(&aszSpeed[0], "1.5"))
341	*penmSpeed = USBTESTSPEED_LOW;
342	else if (!RTStrCmp(&aszSpeed[0], "12"))
343	*penmSpeed = USBTESTSPEED_FULL;
344	else if (!RTStrCmp(&aszSpeed[0], "480"))
345	*penmSpeed = USBTESTSPEED_HIGH;
346	else if ( !RTStrCmp(&aszSpeed[0], "5000")
347	\|\| !RTStrCmp(&aszSpeed[0], "10000"))
348	*penmSpeed = USBTESTSPEED_SUPER;
349	else
350	*penmSpeed = USBTESTSPEED_UNKNOWN;
351	}
352
353	if (pu16BusId)
354	*pu16BusId = (uint16_t)iBusId;
355	if (pu16DevId)
356	*pu16DevId = (uint16_t)iDevId;
357	fFound = true;
358	break;
359	}
360	}
361	else if (rc != VERR_NO_MORE_FILES)
362	rc = VINF_SUCCESS;
363
364	} while ( RT_SUCCESS(rc)
365	&& !fFound);
366
367	if (rc == VERR_NO_MORE_FILES)
368	rc = VINF_SUCCESS;
369
370	RTDirClose(hDirUsb);
371	}
372
373	if (RT_SUCCESS(rc) && !fFound)
374	rc = VERR_NOT_FOUND;
375
376	return rc;
377	}
378
379	/**
380	* Search for a USB test device and return the device path.
381	*
382	* @returns Path to the USB test device or NULL if none was found.
383	*/
384	static char *usbTestFindDevice(void)
385	{
386	/*
387	* Very crude and quick way to search for the correct test device.
388	* Assumption is that the path looks like /dev/bus/usb/%3d/%3d.
389	*/
390	char *pszDevPath = NULL;
391
392	RTDIR hDirUsb = NULL;
393	int rc = RTDirOpen(&hDirUsb, "/dev/bus/usb");
394	if (RT_SUCCESS(rc))
395	{
396	do
397	{
398	RTDIRENTRY DirUsbBus;
399	rc = RTDirRead(hDirUsb, &DirUsbBus, NULL);
400	if (RT_SUCCESS(rc))
401	{
402	char aszPath[RTPATH_MAX + 1];
403	RTStrPrintf(&aszPath[0], RT_ELEMENTS(aszPath), "/dev/bus/usb/%s", DirUsbBus.szName);
404
405	RTDIR hDirUsbBus = NULL;
406	rc = RTDirOpen(&hDirUsbBus, &aszPath[0]);
407	if (RT_SUCCESS(rc))
408	{
409	do
410	{
411	RTDIRENTRY DirUsbDev;
412	rc = RTDirRead(hDirUsbBus, &DirUsbDev, NULL);
413	if (RT_SUCCESS(rc))
414	{
415	char aszPathDev[RTPATH_MAX + 1];
416	RTStrPrintf(&aszPathDev[0], RT_ELEMENTS(aszPathDev), "/dev/bus/usb/%s/%s",
417	DirUsbBus.szName, DirUsbDev.szName);
418
419	RTFILE hFileDev;
420	rc = RTFileOpen(&hFileDev, aszPathDev, RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_NONE);
421	if (RT_SUCCESS(rc))
422	{
423	USBDEVDESC DevDesc;
424
425	rc = RTFileRead(hFileDev, &DevDesc, sizeof(DevDesc), NULL);
426	RTFileClose(hFileDev);
427
428	if ( RT_SUCCESS(rc)
429	&& DevDesc.idVendor == 0x0525
430	&& DevDesc.idProduct == 0xa4a0)
431	pszDevPath = RTStrDup(aszPathDev);
432	}
433
434	rc = VINF_SUCCESS;
435	}
436	else if (rc != VERR_NO_MORE_FILES)
437	rc = VINF_SUCCESS;
438
439	} while ( RT_SUCCESS(rc)
440	&& !pszDevPath);
441
442	rc = VINF_SUCCESS;
443	RTDirClose(hDirUsbBus);
444	}
445	}
446	else if (rc != VERR_NO_MORE_FILES)
447	rc = VINF_SUCCESS;
448	} while ( RT_SUCCESS(rc)
449	&& !pszDevPath);
450
451	RTDirClose(hDirUsb);
452	}
453
454	return pszDevPath;
455	}
456
457	static int usbTestIoctl(int iDevFd, int iInterface, PUSBTESTPARAMS pParams)
458	{
459	struct usbdevfs_ioctl IoCtlData;
460
461	IoCtlData.ifno = iInterface;
462	IoCtlData.ioctl_code = (int)USBTEST_REQUEST;
463	IoCtlData.data = pParams;
464	return ioctl(iDevFd, USBDEVFS_IOCTL, &IoCtlData);
465	}
466
467	/**
468	* Test execution worker.
469	*
470	* @returns nothing.
471	* @param pszDevice The device to use for testing.
472	*/
473	static void usbTestExec(const char *pszDevice)
474	{
475	int iDevFd;
476
477	RTTestSub(g_hTest, "Opening device");
478	iDevFd = open(pszDevice, O_RDWR);
479	if (iDevFd != -1)
480	{
481	USBTESTPARAMS Params;
482
483	RTTestPassed(g_hTest, "Opening device successful\n");
484
485	for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
486	{
487	RTTestSub(g_hTest, g_aTests[i].pszName);
488
489	if (g_aTests[i].fExcluded)
490	{
491	RTTestSkipped(g_hTest, "Excluded from list");
492	continue;
493	}
494
495	int rc = g_aTests[i].pfnParamsSetup(i, g_aTests[i].pszName, &Params);
496	if (RT_SUCCESS(rc))
497	{
498	Params.idxTest = i;
499
500	/* Assume the test interface has the number 0 for now. */
501	int rcPosix = usbTestIoctl(iDevFd, 0, &Params);
502	if (rcPosix < 0 && errno == EOPNOTSUPP)
503	{
504	RTTestSkipped(g_hTest, "Not supported");
505	continue;
506	}
507
508	if (rcPosix < 0)
509	{
510	/*
511	* The error status code of the unlink testcase is
512	* offset by 2000 for the sync and 1000 for the sync code path
513	* (see drivers/usb/misc/usbtest.c in the Linux kernel sources).
514	*
515	* Adjust to the actual status code so converting doesn't assert.
516	*/
517	int iTmpErrno = errno;
518	if (iTmpErrno >= 2000)
519	iTmpErrno -= 2000;
520	else if (iTmpErrno >= 1000)
521	iTmpErrno -= 1000;
522	RTTestFailed(g_hTest, "Test failed with %Rrc\n", RTErrConvertFromErrno(iTmpErrno));
523	}
524	else
525	{
526	uint64_t u64Ns = Params.TimeTest.tv_sec * RT_NS_1SEC + Params.TimeTest.tv_usec * RT_NS_1US;
527	RTTestValue(g_hTest, "Runtime", u64Ns, RTTESTUNIT_NS);
528	}
529	}
530	else
531	RTTestFailed(g_hTest, "Setting up test parameters failed with %Rrc\n", rc);
532	RTTestSubDone(g_hTest);
533	}
534
535	close(iDevFd);
536	}
537	else
538	RTTestFailed(g_hTest, "Opening device failed with %Rrc\n", RTErrConvertFromErrno(errno));
539
540	}
541
542	int main(int argc, char *argv[])
543	{
544	/*
545	* Init IPRT and globals.
546	*/
547	int rc = RTTestInitAndCreate("UsbTest", &g_hTest);
548	if (rc)
549	return rc;
550
551	/*
552	* Default values.
553	*/
554	const char *pszDevice = NULL;
555
556	RTGETOPTUNION ValueUnion;
557	RTGETOPTSTATE GetState;
558	RTGetOptInit(&GetState, argc, argv, g_aCmdOptions, RT_ELEMENTS(g_aCmdOptions), 1, 0 /* fFlags */);
559	while ((rc = RTGetOpt(&GetState, &ValueUnion)))
560	{
561	switch (rc)
562	{
563	case 'h':
564	usbTestUsage(g_pStdOut);
565	return RTEXITCODE_SUCCESS;
566	case 'd':
567	pszDevice = ValueUnion.psz;
568	break;
569	case 's':
570	if (!RTStrICmp(ValueUnion.psz, "Low"))
571	g_enmSpeed = USBTESTSPEED_LOW;
572	else if (!RTStrICmp(ValueUnion.psz, "Full"))
573	g_enmSpeed = USBTESTSPEED_FULL;
574	else if (!RTStrICmp(ValueUnion.psz, "High"))
575	g_enmSpeed = USBTESTSPEED_HIGH;
576	else if (!RTStrICmp(ValueUnion.psz, "Super"))
577	g_enmSpeed = USBTESTSPEED_SUPER;
578	else
579	{
580	RTTestPrintf(g_hTest, RTTESTLVL_FAILURE, "Invalid speed passed to --expected-speed\n");
581	RTTestErrorInc(g_hTest);
582	return RTGetOptPrintError(VERR_INVALID_PARAMETER, &ValueUnion);
583	}
584	break;
585	case 'e':
586	if (ValueUnion.u32 < RT_ELEMENTS(g_aTests))
587	g_aTests[ValueUnion.u32].fExcluded = true;
588	else
589	{
590	RTTestPrintf(g_hTest, RTTESTLVL_FAILURE, "Invalid test number passed to --exclude\n");
591	RTTestErrorInc(g_hTest);
592	return RTGetOptPrintError(VERR_INVALID_PARAMETER, &ValueUnion);
593	}
594	break;
595	case 'a':
596	for (unsigned i = 0; i < RT_ELEMENTS(g_aTests); i++)
597	g_aTests[i].fExcluded = true;
598	break;
599	case 'i':
600	if (ValueUnion.u32 < RT_ELEMENTS(g_aTests))
601	g_aTests[ValueUnion.u32].fExcluded = false;
602	else
603	{
604	RTTestPrintf(g_hTest, RTTESTLVL_FAILURE, "Invalid test number passed to --include\n");
605	RTTestErrorInc(g_hTest);
606	return RTGetOptPrintError(VERR_INVALID_PARAMETER, &ValueUnion);
607	}
608	break;
609	default:
610	return RTGetOptPrintError(rc, &ValueUnion);
611	}
612	}
613
614	/*
615	* Start testing.
616	*/
617	RTTestBanner(g_hTest);
618
619	/* Find the first test device if none was given. */
620	if (!pszDevice)
621	{
622	RTTestSub(g_hTest, "Detecting device");
623	pszDevice = usbTestFindDevice();
624	if (!pszDevice)
625	RTTestFailed(g_hTest, "Failed to find suitable device\n");
626
627	RTTestSubDone(g_hTest);
628	}
629
630	if (pszDevice)
631	{
632	/* First check that the requested speed matches. */
633	if (g_enmSpeed != USBTESTSPEED_ANY)
634	{
635	RTTestSub(g_hTest, "Checking correct device speed");
636
637	USBTESTSPEED enmSpeed = USBTESTSPEED_UNKNOWN;
638	rc = usbTestDeviceQueryBusAndDevId(NULL, NULL, &enmSpeed);
639	if (RT_SUCCESS(rc))
640	{
641	if (enmSpeed == g_enmSpeed)
642	RTTestPassed(g_hTest, "Reported device speed matches requested speed\n");
643	else
644	RTTestFailed(g_hTest, "Reported device speed doesn'match requested speed (%u vs %u)\n",
645	enmSpeed, g_enmSpeed);
646	}
647	else
648	RTTestFailed(g_hTest, "Failed to query device speed with rc=%Rrc\n", rc);
649
650	RTTestSubDone(g_hTest);
651	}
652	usbTestExec(pszDevice);
653	}
654
655	RTEXITCODE rcExit = RTTestSummaryAndDestroy(g_hTest);
656	return rcExit;
657	}
658

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ValidationKit/utils/usb/UsbTest.cpp@ 76553

Download in other formats: