VUSBUrbTrace.cpp@ 100512

Last change on this file since 100512 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.7 KB

Line
1	/* $Id: VUSBUrbTrace.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* Virtual USB - URBs.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DRV_VUSB
33	#include <VBox/vmm/pdm.h>
34	#include <VBox/vmm/vmapi.h>
35	#include <iprt/errcore.h>
36	#include <iprt/alloc.h>
37	#include <VBox/log.h>
38	#include <iprt/time.h>
39	#include <iprt/thread.h>
40	#include <iprt/semaphore.h>
41	#include <iprt/string.h>
42	#include <iprt/assert.h>
43	#include <iprt/asm.h>
44	#include <iprt/env.h>
45	#include "VUSBInternal.h"
46
47
48
49	#ifdef LOG_ENABLED
50	DECLINLINE(const char *) GetScsiErrCd(uint8_t ScsiErr)
51	{
52	switch (ScsiErr)
53	{
54	case 0: return "?";
55	}
56	return "?";
57	}
58
59	DECLINLINE(const char *) GetScsiKCQ(uint8_t Key, uint8_t ASC, uint8_t ASCQ)
60	{
61	switch (Key)
62	{
63	case 0:
64	switch (RT_MAKE_U16(ASC, ASCQ))
65	{
66	case RT_MAKE_U16(0x00, 0x00): return "No error";
67	}
68	break;
69
70	case 1:
71	return "Soft Error";
72
73	case 2:
74	return "Not Ready";
75
76	case 3:
77	return "Medium Error";
78
79	case 4:
80	return "Hard Error";
81
82	case 5:
83	return "Illegal Request";
84
85	case 6:
86	return "Unit Attention";
87
88	case 7:
89	return "Write Protected";
90
91	case 0xb:
92	return "Aborted Command";
93	}
94	return "?";
95	}
96
97	DECLHIDDEN(const char *) vusbUrbStatusName(VUSBSTATUS enmStatus)
98	{
99	/** Strings for the URB statuses. */
100	static const char * const s_apszNames[] =
101	{
102	"OK",
103	"STALL",
104	"ERR_DNR",
105	"ERR_CRC",
106	"DATA_UNDERRUN",
107	"DATA_OVERRUN",
108	"NOT_ACCESSED",
109	"7", "8", "9", "10", "11", "12", "13", "14", "15"
110	};
111
112	return enmStatus < (int)RT_ELEMENTS(s_apszNames)
113	? s_apszNames[enmStatus]
114	: enmStatus == VUSBSTATUS_INVALID
115	? "INVALID"
116	: "??";
117	}
118
119	DECLHIDDEN(const char *) vusbUrbDirName(VUSBDIRECTION enmDir)
120	{
121	/** Strings for the URB directions. */
122	static const char * const s_apszNames[] =
123	{
124	"setup",
125	"in",
126	"out"
127	};
128
129	return enmDir < (int)RT_ELEMENTS(s_apszNames)
130	? s_apszNames[enmDir]
131	: "??";
132	}
133
134	DECLHIDDEN(const char *) vusbUrbTypeName(VUSBXFERTYPE enmType)
135	{
136	/** Strings for the URB types. */
137	static const char * const s_apszName[] =
138	{
139	"control-part",
140	"isochronous",
141	"bulk",
142	"interrupt",
143	"control"
144	};
145
146	return enmType < (int)RT_ELEMENTS(s_apszName)
147	? s_apszName[enmType]
148	: "??";
149	}
150
151	/**
152	* Logs an URB.
153	*
154	* Note that pUrb->pVUsb->pDev and pUrb->pVUsb->pDev->pUsbIns can all be NULL.
155	*/
156	DECLHIDDEN(void) vusbUrbTrace(PVUSBURB pUrb, const char *pszMsg, bool fComplete)
157	{
158	PVUSBDEV pDev = pUrb->pVUsb ? pUrb->pVUsb->pDev : NULL; /* Can be NULL when called from usbProxyConstruct and friends. */
159	PVUSBPIPE pPipe = pDev ? &pDev->aPipes[pUrb->EndPt] : NULL;
160	const uint8_t *pbData = pUrb->abData;
161	uint32_t cbData = pUrb->cbData;
162	PCVUSBSETUP pSetup = NULL;
163	bool fDescriptors = false;
164	static size_t s_cchMaxMsg = 10;
165	size_t cchMsg = strlen(pszMsg);
166	if (cchMsg > s_cchMaxMsg)
167	s_cchMaxMsg = cchMsg;
168
169	Log(("%s: %*s: pDev=%p[%s] rc=%s a=%i e=%u d=%s t=%s cb=%#x(%d) ts=%RU64 (%RU64 ns ago) %s\n",
170	pUrb->pszDesc, s_cchMaxMsg, pszMsg,
171	pDev,
172	pUrb->pVUsb && pUrb->pVUsb->pDev && pUrb->pVUsb->pDev->pUsbIns ? pUrb->pVUsb->pDev->pUsbIns->pszName : "",
173	vusbUrbStatusName(pUrb->enmStatus),
174	pDev ? pDev->u8Address : -1,
175	pUrb->EndPt,
176	vusbUrbDirName(pUrb->enmDir),
177	vusbUrbTypeName(pUrb->enmType),
178	pUrb->cbData,
179	pUrb->cbData,
180	pUrb->pVUsb ? pUrb->pVUsb->u64SubmitTS : 0,
181	pUrb->pVUsb ? RTTimeNanoTS() - pUrb->pVUsb->u64SubmitTS : 0,
182	pUrb->fShortNotOk ? "ShortNotOk" : "ShortOk"));
183
184	#ifndef DEBUG_bird
185	if ( pUrb->enmType == VUSBXFERTYPE_CTRL
186	&& pUrb->enmStatus == VUSBSTATUS_OK)
187	return;
188	#endif
189
190	if ( pUrb->enmType == VUSBXFERTYPE_MSG
191	\|\| ( pUrb->enmDir == VUSBDIRECTION_SETUP
192	&& pUrb->enmType == VUSBXFERTYPE_CTRL
193	&& cbData))
194	{
195	static const char * const s_apszReqDirs[] = {"host2dev", "dev2host"};
196	static const char * const s_apszReqTypes[] = {"std", "class", "vendor", "reserved"};
197	static const char * const s_apszReqRecipients[] = {"dev", "if", "endpoint", "other"};
198	static const char * const s_apszRequests[] =
199	{
200	"GET_STATUS", "CLEAR_FEATURE", "2?", "SET_FEATURE",
201	"4?", "SET_ADDRESS", "GET_DESCRIPTOR", "SET_DESCRIPTOR",
202	"GET_CONFIGURATION", "SET_CONFIGURATION", "GET_INTERFACE", "SET_INTERFACE",
203	"SYNCH_FRAME"
204	};
205	pSetup = (PVUSBSETUP)pUrb->abData;
206	pbData += sizeof(*pSetup);
207	cbData -= sizeof(*pSetup);
208
209	Log(("%s: %*s: CTRL: bmRequestType=0x%.2x (%s %s %s) bRequest=0x%.2x (%s) wValue=0x%.4x wIndex=0x%.4x wLength=0x%.4x\n",
210	pUrb->pszDesc, s_cchMaxMsg, pszMsg,
211	pSetup->bmRequestType, s_apszReqDirs[pSetup->bmRequestType >> 7], s_apszReqTypes[(pSetup->bmRequestType >> 5) & 0x3],
212	(unsigned)(pSetup->bmRequestType & 0xf) < RT_ELEMENTS(s_apszReqRecipients) ? s_apszReqRecipients[pSetup->bmRequestType & 0xf] : "??",
213	pSetup->bRequest, pSetup->bRequest < RT_ELEMENTS(s_apszRequests) ? s_apszRequests[pSetup->bRequest] : "??",
214	pSetup->wValue, pSetup->wIndex, pSetup->wLength));
215
216	if ( pSetup->bRequest == VUSB_REQ_GET_DESCRIPTOR
217	&& fComplete
218	&& pUrb->enmStatus == VUSBSTATUS_OK
219	&& ((pSetup->bmRequestType >> 5) & 0x3) < 2 /* vendor */)
220	fDescriptors = true;
221	}
222	else if ( fComplete
223	&& pUrb->enmDir == VUSBDIRECTION_IN
224	&& pUrb->enmType == VUSBXFERTYPE_CTRL
225	&& pUrb->enmStatus == VUSBSTATUS_OK
226	&& pPipe->pCtrl
227	&& pPipe->pCtrl->enmStage == CTLSTAGE_DATA
228	&& cbData > 0)
229	{
230	pSetup = pPipe->pCtrl->pMsg;
231	if (pSetup->bRequest == VUSB_REQ_GET_DESCRIPTOR)
232	{
233	/* HID report (0x22) and physical (0x23) descriptors do not use standard format
234	* with descriptor length/type at the front. Don't try to dump them, we'll only
235	* misinterpret them.
236	*/
237	if ( ((pSetup->bmRequestType >> 5) & 0x3) == 1 /* class */
238	&& ((RT_HIBYTE(pSetup->wValue) == 0x22) \|\| (RT_HIBYTE(pSetup->wValue) == 0x23)))
239	{
240	fDescriptors = false;
241	}
242	}
243	else
244	fDescriptors = true;
245	}
246
247	/*
248	* Dump descriptors.
249	*/
250	if (fDescriptors)
251	{
252	const uint8_t *pb = pbData;
253	const uint8_t *pbEnd = pbData + cbData;
254	while (pb + 1 < pbEnd)
255	{
256	const unsigned cbLeft = pbEnd - pb;
257	const unsigned cbLength = *pb;
258	unsigned cb = cbLength;
259	uint8_t bDescriptorType = pb[1];
260
261	/* length out of bounds? */
262	if (cbLength > cbLeft)
263	{
264	cb = cbLeft;
265	if (cbLength != 0xff) /* ignore this */
266	Log(("URB: %*s: DESC: warning descriptor length goes beyond the end of the URB! cbLength=%d cbLeft=%d\n",
267	s_cchMaxMsg, pszMsg, cbLength, cbLeft));
268	}
269
270	if (cb >= 2)
271	{
272	Log(("URB: %*s: DESC: %04x: %25s = %#04x (%d)\n"
273	"URB: %*s: %04x: %25s = %#04x (",
274	s_cchMaxMsg, pszMsg, pb - pbData, "bLength", cbLength, cbLength,
275	s_cchMaxMsg, pszMsg, pb - pbData + 1, "bDescriptorType", bDescriptorType));
276
277	#pragma pack(1)
278	#define BYTE_FIELD(strct, memb) \
279	if ((unsigned)RT_OFFSETOF(strct, memb) < cb) \
280	Log(("URB: %*s: %04x: %25s = %#04x\n", s_cchMaxMsg, pszMsg, \
281	pb + RT_OFFSETOF(strct, memb) - pbData, #memb, pb[RT_OFFSETOF(strct, memb)]))
282	#define BYTE_FIELD_START(strct, memb) do { \
283	if ((unsigned)RT_OFFSETOF(strct, memb) < cb) \
284	{ \
285	Log(("URB: %*s: %04x: %25s = %#04x", s_cchMaxMsg, pszMsg, \
286	pb + RT_OFFSETOF(strct, memb) - pbData, #memb, pb[RT_OFFSETOF(strct, memb)]))
287	#define BYTE_FIELD_END(strct, memb) \
288	Log(("\n")); \
289	} } while (0)
290	#define WORD_FIELD(strct, memb) \
291	if ((unsigned)RT_OFFSETOF(strct, memb) + 1 < cb) \
292	Log(("URB: %*s: %04x: %25s = %#06x\n", s_cchMaxMsg, pszMsg, \
293	pb + RT_OFFSETOF(strct, memb) - pbData, #memb, (uint16_t )&pb[RT_OFFSETOF(strct, memb)]))
294	#define BCD_FIELD(strct, memb) \
295	if ((unsigned)RT_OFFSETOF(strct, memb) + 1 < cb) \
296	Log(("URB: %*s: %04x: %25s = %#06x (%02x.%02x)\n", s_cchMaxMsg, pszMsg, \
297	pb + RT_OFFSETOF(strct, memb) - pbData, #memb, (uint16_t )&pb[RT_OFFSETOF(strct, memb)], \
298	pb[RT_OFFSETOF(strct, memb) + 1], pb[RT_OFFSETOF(strct, memb)]))
299	#define SIZE_CHECK(strct) \
300	if (cb > sizeof(strct)) \
301	Log(("URB: %s: %04x: WARNING %d extra byte(s) %.Rhxs\n", s_cchMaxMsg, pszMsg, \
302	pb + sizeof(strct) - pbData, cb - sizeof(strct), cb - sizeof(strct), pb + sizeof(strct))); \
303	else if (cb < sizeof(strct)) \
304	Log(("URB: %*s: %04x: WARNING %d missing byte(s)! Expected size %d.\n", s_cchMaxMsg, pszMsg, \
305	pb + cb - pbData, sizeof(strct) - cb, sizeof(strct)))
306
307	/* on type */
308	switch (bDescriptorType)
309	{
310	case VUSB_DT_DEVICE:
311	{
312	struct dev_desc
313	{
314	uint8_t bLength;
315	uint8_t bDescriptorType;
316	uint16_t bcdUSB;
317	uint8_t bDeviceClass;
318	uint8_t bDeviceSubClass;
319	uint8_t bDeviceProtocol;
320	uint8_t bMaxPacketSize0;
321	uint16_t idVendor;
322	uint16_t idProduct;
323	uint16_t bcdDevice;
324	uint8_t iManufacturer;
325	uint8_t iProduct;
326	uint8_t iSerialNumber;
327	uint8_t bNumConfigurations;
328	} pDesc = (struct dev_desc )pb; NOREF(pDesc);
329	Log(("DEV)\n"));
330	BCD_FIELD( struct dev_desc, bcdUSB);
331	BYTE_FIELD(struct dev_desc, bDeviceClass);
332	BYTE_FIELD(struct dev_desc, bDeviceSubClass);
333	BYTE_FIELD(struct dev_desc, bDeviceProtocol);
334	BYTE_FIELD(struct dev_desc, bMaxPacketSize0);
335	WORD_FIELD(struct dev_desc, idVendor);
336	WORD_FIELD(struct dev_desc, idProduct);
337	BCD_FIELD( struct dev_desc, bcdDevice);
338	BYTE_FIELD(struct dev_desc, iManufacturer);
339	BYTE_FIELD(struct dev_desc, iProduct);
340	BYTE_FIELD(struct dev_desc, iSerialNumber);
341	BYTE_FIELD(struct dev_desc, bNumConfigurations);
342	SIZE_CHECK(struct dev_desc);
343	break;
344	}
345
346	case VUSB_DT_CONFIG:
347	{
348	struct cfg_desc
349	{
350	uint8_t bLength;
351	uint8_t bDescriptorType;
352	uint16_t wTotalLength;
353	uint8_t bNumInterfaces;
354	uint8_t bConfigurationValue;
355	uint8_t iConfiguration;
356	uint8_t bmAttributes;
357	uint8_t MaxPower;
358	} pDesc = (struct cfg_desc )pb; NOREF(pDesc);
359	Log(("CFG)\n"));
360	WORD_FIELD(struct cfg_desc, wTotalLength);
361	BYTE_FIELD(struct cfg_desc, bNumInterfaces);
362	BYTE_FIELD(struct cfg_desc, bConfigurationValue);
363	BYTE_FIELD(struct cfg_desc, iConfiguration);
364	BYTE_FIELD_START(struct cfg_desc, bmAttributes);
365	static const char * const s_apszTransType[4] = { "Control", "Isochronous", "Bulk", "Interrupt" };
366	static const char * const s_apszSyncType[4] = { "NoSync", "Asynchronous", "Adaptive", "Synchronous" };
367	static const char * const s_apszUsageType[4] = { "Data ep", "Feedback ep.", "Implicit feedback Data ep.", "Reserved" };
368	Log((" %s - %s - %s", s_apszTransType[(pDesc->bmAttributes & 0x3)],
369	s_apszSyncType[((pDesc->bmAttributes >> 2) & 0x3)], s_apszUsageType[((pDesc->bmAttributes >> 4) & 0x3)]));
370	BYTE_FIELD_END(struct cfg_desc, bmAttributes);
371	BYTE_FIELD(struct cfg_desc, MaxPower);
372	SIZE_CHECK(struct cfg_desc);
373	break;
374	}
375
376	case VUSB_DT_STRING:
377	if (!pSetup->wIndex)
378	{
379	/* langid array */
380	uint16_t pu16 = (uint16_t )pb + 1;
381	Log(("LANGIDs)\n"));
382	while ((uintptr_t)pu16 + 2 - (uintptr_t)pb <= cb)
383	{
384	Log(("URB: %*s: %04x: wLANGID[%#x] = %#06x\n",
385	s_cchMaxMsg, pszMsg, (uint8_t )pu16 - pbData, pu16 - (uint16_t )pb, *pu16));
386	pu16++;
387	}
388	if (cb & 1)
389	Log(("URB: %*s: %04x: WARNING descriptor size is odd! extra byte: %02\n",
390	s_cchMaxMsg, pszMsg, (uint8_t )pu16 - pbData, (uint8_t *)pu16));
391	}
392	else
393	{
394	/** a string. */
395	Log(("STRING)\n"));
396	if (cb > 2)
397	Log(("URB: %s: %04x: Length=%d String=%.ls\n",
398	s_cchMaxMsg, pszMsg, pb - pbData, cb - 2, cb / 2 - 1, pb + 2));
399	else
400	Log(("URB: %*s: %04x: Length=0\n", s_cchMaxMsg, pszMsg, pb - pbData));
401	}
402	break;
403
404	case VUSB_DT_INTERFACE:
405	{
406	struct if_desc
407	{
408	uint8_t bLength;
409	uint8_t bDescriptorType;
410	uint8_t bInterfaceNumber;
411	uint8_t bAlternateSetting;
412	uint8_t bNumEndpoints;
413	uint8_t bInterfaceClass;
414	uint8_t bInterfaceSubClass;
415	uint8_t bInterfaceProtocol;
416	uint8_t iInterface;
417	} pDesc = (struct if_desc )pb; NOREF(pDesc);
418	Log(("IF)\n"));
419	BYTE_FIELD(struct if_desc, bInterfaceNumber);
420	BYTE_FIELD(struct if_desc, bAlternateSetting);
421	BYTE_FIELD(struct if_desc, bNumEndpoints);
422	BYTE_FIELD(struct if_desc, bInterfaceClass);
423	BYTE_FIELD(struct if_desc, bInterfaceSubClass);
424	BYTE_FIELD(struct if_desc, bInterfaceProtocol);
425	BYTE_FIELD(struct if_desc, iInterface);
426	SIZE_CHECK(struct if_desc);
427	break;
428	}
429
430	case VUSB_DT_ENDPOINT:
431	{
432	struct ep_desc
433	{
434	uint8_t bLength;
435	uint8_t bDescriptorType;
436	uint8_t bEndpointAddress;
437	uint8_t bmAttributes;
438	uint16_t wMaxPacketSize;
439	uint8_t bInterval;
440	} pDesc = (struct ep_desc )pb; NOREF(pDesc);
441	Log(("EP)\n"));
442	BYTE_FIELD(struct ep_desc, bEndpointAddress);
443	BYTE_FIELD(struct ep_desc, bmAttributes);
444	WORD_FIELD(struct ep_desc, wMaxPacketSize);
445	BYTE_FIELD(struct ep_desc, bInterval);
446	SIZE_CHECK(struct ep_desc);
447	break;
448	}
449
450	case VUSB_DT_DEVICE_QUALIFIER:
451	{
452	struct dq_desc
453	{
454	uint8_t bLength;
455	uint8_t bDescriptorType;
456	uint16_t bcdUSB;
457	uint8_t bDeviceClass;
458	uint8_t bDeviceSubClass;
459	uint8_t bDeviceProtocol;
460	uint8_t bMaxPacketSize0;
461	uint8_t bNumConfigurations;
462	uint8_t bReserved;
463	} pDQDesc = (struct dq_desc )pb; NOREF(pDQDesc);
464	Log(("DEVQ)\n"));
465	BCD_FIELD( struct dq_desc, bcdUSB);
466	BYTE_FIELD(struct dq_desc, bDeviceClass);
467	BYTE_FIELD(struct dq_desc, bDeviceSubClass);
468	BYTE_FIELD(struct dq_desc, bDeviceProtocol);
469	BYTE_FIELD(struct dq_desc, bMaxPacketSize0);
470	BYTE_FIELD(struct dq_desc, bNumConfigurations);
471	BYTE_FIELD(struct dq_desc, bReserved);
472	SIZE_CHECK(struct dq_desc);
473	break;
474	}
475
476	case VUSB_DT_OTHER_SPEED_CFG:
477	{
478	struct oth_cfg_desc
479	{
480	uint8_t bLength;
481	uint8_t bDescriptorType;
482	uint16_t wTotalLength;
483	uint8_t bNumInterfaces;
484	uint8_t bConfigurationValue;
485	uint8_t iConfiguration;
486	uint8_t bmAttributes;
487	uint8_t MaxPower;
488	} pDesc = (struct oth_cfg_desc )pb; NOREF(pDesc);
489	Log(("OCFG)\n"));
490	WORD_FIELD(struct oth_cfg_desc, wTotalLength);
491	BYTE_FIELD(struct oth_cfg_desc, bNumInterfaces);
492	BYTE_FIELD(struct oth_cfg_desc, bConfigurationValue);
493	BYTE_FIELD(struct oth_cfg_desc, iConfiguration);
494	BYTE_FIELD_START(struct oth_cfg_desc, bmAttributes);
495	static const char * const s_apszTransType[4] = { "Control", "Isochronous", "Bulk", "Interrupt" };
496	static const char * const s_apszSyncType[4] = { "NoSync", "Asynchronous", "Adaptive", "Synchronous" };
497	static const char * const s_apszUsageType[4] = { "Data ep", "Feedback ep.", "Implicit feedback Data ep.", "Reserved" };
498	Log((" %s - %s - %s", s_apszTransType[(pDesc->bmAttributes & 0x3)],
499	s_apszSyncType[((pDesc->bmAttributes >> 2) & 0x3)], s_apszUsageType[((pDesc->bmAttributes >> 4) & 0x3)]));
500	BYTE_FIELD_END(struct oth_cfg_desc, bmAttributes);
501	BYTE_FIELD(struct oth_cfg_desc, MaxPower);
502	SIZE_CHECK(struct oth_cfg_desc);
503	break;
504	}
505
506	case 0x21:
507	{
508	struct hid_desc
509	{
510	uint8_t bLength;
511	uint8_t bDescriptorType;
512	uint16_t bcdHid;
513	uint8_t bCountry;
514	uint8_t bNumDescriptors;
515	uint8_t bReportType;
516	uint16_t wReportLength;
517	} pDesc = (struct hid_desc )pb; NOREF(pDesc);
518	Log(("EP)\n"));
519	BCD_FIELD( struct hid_desc, bcdHid);
520	BYTE_FIELD(struct hid_desc, bCountry);
521	BYTE_FIELD(struct hid_desc, bNumDescriptors);
522	BYTE_FIELD(struct hid_desc, bReportType);
523	WORD_FIELD(struct hid_desc, wReportLength);
524	SIZE_CHECK(struct hid_desc);
525	break;
526	}
527
528	case 0xff:
529	Log(("UNKNOWN-ignore)\n"));
530	break;
531
532	default:
533	Log(("UNKNOWN)!!!\n"));
534	break;
535	}
536
537	#undef BYTE_FIELD
538	#undef WORD_FIELD
539	#undef BCD_FIELD
540	#undef SIZE_CHECK
541	#pragma pack()
542	}
543	else
544	{
545	Log(("URB: %*s: DESC: %04x: bLength=%d bDescriptorType=%d - invalid length\n",
546	s_cchMaxMsg, pszMsg, pb - pbData, cb, bDescriptorType));
547	break;
548	}
549
550	/* next */
551	pb += cb;
552	}
553	}
554
555	/*
556	* SCSI
557	*/
558	if ( pUrb->enmType == VUSBXFERTYPE_BULK
559	&& pUrb->enmDir == VUSBDIRECTION_OUT
560	&& pUrb->cbData >= 12
561	&& !memcmp(pUrb->abData, "USBC", 4))
562	{
563	const struct usbc
564	{
565	uint32_t Signature;
566	uint32_t Tag;
567	uint32_t DataTransferLength;
568	uint8_t Flags;
569	uint8_t Lun;
570	uint8_t Length;
571	uint8_t CDB[13];
572	} pUsbC = (struct usbc )pUrb->abData;
573	Log(("URB: %s: SCSI: Tag=%#x DataTransferLength=%#x Flags=%#x Lun=%#x Length=%#x CDB=%.Rhxs\n",
574	s_cchMaxMsg, pszMsg, pUsbC->Tag, pUsbC->DataTransferLength, pUsbC->Flags, pUsbC->Lun,
575	pUsbC->Length, pUsbC->Length, pUsbC->CDB));
576	const uint8_t *pb = &pUsbC->CDB[0];
577	switch (pb[0])
578	{
579	case 0x00: /* test unit read */
580	Log(("URB: %*s: SCSI: TEST_UNIT_READY LUN=%d Ctrl=%#RX8\n",
581	s_cchMaxMsg, pszMsg, pb[1] >> 5, pb[5]));
582	break;
583	case 0x03: /* Request Sense command */
584	Log(("URB: %*s: SCSI: REQUEST_SENSE LUN=%d AlcLen=%#RX16 Ctrl=%#RX8\n",
585	s_cchMaxMsg, pszMsg, pb[1] >> 5, pb[4], pb[5]));
586	break;
587	case 0x12: /* Inquiry command. */
588	Log(("URB: %*s: SCSI: INQUIRY EVPD=%d LUN=%d PgCd=%#RX8 AlcLen=%#RX8 Ctrl=%#RX8\n",
589	s_cchMaxMsg, pszMsg, pb[1] & 1, pb[1] >> 5, pb[2], pb[4], pb[5]));
590	break;
591	case 0x1a: /* Mode Sense(6) command */
592	Log(("URB: %*s: SCSI: MODE_SENSE6 LUN=%d DBD=%d PC=%d PgCd=%#RX8 AlcLen=%#RX8 Ctrl=%#RX8\n",
593	s_cchMaxMsg, pszMsg, pb[1] >> 5, !!(pb[1] & RT_BIT(3)), pb[2] >> 6, pb[2] & 0x3f, pb[4], pb[5]));
594	break;
595	case 0x5a:
596	Log(("URB: %*s: SCSI: MODE_SENSE10 LUN=%d DBD=%d PC=%d PgCd=%#RX8 AlcLen=%#RX16 Ctrl=%#RX8\n",
597	s_cchMaxMsg, pszMsg, pb[1] >> 5, !!(pb[1] & RT_BIT(3)), pb[2] >> 6, pb[2] & 0x3f,
598	RT_MAKE_U16(pb[8], pb[7]), pb[9]));
599	break;
600	case 0x25: /* Read Capacity(6) command. */
601	Log(("URB: %*s: SCSI: READ_CAPACITY\n",
602	s_cchMaxMsg, pszMsg));
603	break;
604	case 0x28: /* Read(10) command. */
605	Log(("URB: %*s: SCSI: READ10 RelAdr=%d FUA=%d DPO=%d LUN=%d LBA=%#RX32 Len=%#RX16 Ctrl=%#RX8\n",
606	s_cchMaxMsg, pszMsg,
607	pb[1] & 1, !!(pb[1] & RT_BIT(3)), !!(pb[1] & RT_BIT(4)), pb[1] >> 5,
608	RT_MAKE_U32_FROM_U8(pb[5], pb[4], pb[3], pb[2]),
609	RT_MAKE_U16(pb[8], pb[7]), pb[9]));
610	break;
611	case 0xa8: /* Read(12) command. */
612	Log(("URB: %*s: SCSI: READ12 RelAdr=%d FUA=%d DPO=%d LUN=%d LBA=%#RX32 Len=%#RX32 Ctrl=%#RX8\n",
613	s_cchMaxMsg, pszMsg,
614	pb[1] & 1, !!(pb[1] & RT_BIT(3)), !!(pb[1] & RT_BIT(4)), pb[1] >> 5,
615	RT_MAKE_U32_FROM_U8(pb[5], pb[4], pb[3], pb[2]),
616	RT_MAKE_U32_FROM_U8(pb[9], pb[8], pb[7], pb[6]),
617	pb[11]));
618	break;
619	case 0x3e: /* Read Long command. */
620	Log(("URB: %*s: SCSI: READ LONG RelAdr=%d Correct=%d LUN=%d LBA=%#RX16 ByteLen=%#RX16 Ctrl=%#RX8\n",
621	s_cchMaxMsg, pszMsg,
622	pb[1] & 1, !!(pb[1] & RT_BIT(1)), pb[1] >> 5,
623	RT_MAKE_U16(pb[3], pb[2]), RT_MAKE_U16(pb[6], pb[5]),
624	pb[11]));
625	break;
626	case 0x2a: /* Write(10) command. */
627	Log(("URB: %*s: SCSI: WRITE10 RelAdr=%d EBP=%d FUA=%d DPO=%d LUN=%d LBA=%#RX32 Len=%#RX16 Ctrl=%#RX8\n",
628	s_cchMaxMsg, pszMsg,
629	pb[1] & 1, !!(pb[1] & RT_BIT(2)), !!(pb[1] & RT_BIT(3)),
630	!!(pb[1] & RT_BIT(4)), pb[1] >> 5,
631	RT_MAKE_U32_FROM_U8(pb[5], pb[4], pb[3], pb[2]),
632	RT_MAKE_U16(pb[8], pb[7]), pb[9]));
633	break;
634	case 0xaa: /* Write(12) command. */
635	Log(("URB: %*s: SCSI: WRITE12 RelAdr=%d EBP=%d FUA=%d DPO=%d LUN=%d LBA=%#RX32 Len=%#RX32 Ctrl=%#RX8\n",
636	s_cchMaxMsg, pszMsg,
637	pb[1] & 1, !!(pb[1] & RT_BIT(3)), !!(pb[1] & RT_BIT(4)),
638	!!(pb[1] & RT_BIT(4)), pb[1] >> 5,
639	RT_MAKE_U32_FROM_U8(pb[5], pb[4], pb[3], pb[2]),
640	RT_MAKE_U32_FROM_U8(pb[9], pb[8], pb[7], pb[6]),
641	pb[11]));
642	break;
643	case 0x3f: /* Write Long command. */
644	Log(("URB: %*s: SCSI: WRITE LONG RelAdr=%d LUN=%d LBA=%#RX16 ByteLen=%#RX16 Ctrl=%#RX8\n",
645	s_cchMaxMsg, pszMsg,
646	pb[1] & 1, pb[1] >> 5,
647	RT_MAKE_U16(pb[3], pb[2]), RT_MAKE_U16(pb[6], pb[5]),
648	pb[11]));
649	break;
650	case 0x35: /* Synchronize Cache(10) command. */
651	Log(("URB: %*s: SCSI: SYNCHRONIZE_CACHE10\n",
652	s_cchMaxMsg, pszMsg));
653	break;
654	case 0xa0: /* Report LUNs command. */
655	Log(("URB: %*s: SCSI: REPORT_LUNS\n",
656	s_cchMaxMsg, pszMsg));
657	break;
658	default:
659	Log(("URB: %*s: SCSI: cmd=%#x\n",
660	s_cchMaxMsg, pszMsg, pb[0]));
661	break;
662	}
663	if (pDev)
664	pDev->Urb.u8ScsiCmd = pb[0];
665	}
666	else if ( fComplete
667	&& pUrb->enmType == VUSBXFERTYPE_BULK
668	&& pUrb->enmDir == VUSBDIRECTION_IN
669	&& pUrb->cbData >= 12
670	&& !memcmp(pUrb->abData, "USBS", 4))
671	{
672	const struct usbs
673	{
674	uint32_t Signature;
675	uint32_t Tag;
676	uint32_t DataResidue;
677	uint8_t Status;
678	uint8_t CDB[3];
679	} pUsbS = (struct usbs )pUrb->abData;
680	static const char * const s_apszStatuses[] = { "PASSED", "FAILED", "PHASE ERROR", "RESERVED" };
681	Log(("URB: %*s: SCSI: Tag=%#x DataResidue=%#RX32 Status=%#RX8 %s\n",
682	s_cchMaxMsg, pszMsg, pUsbS->Tag, pUsbS->DataResidue, pUsbS->Status,
683	s_apszStatuses[pUsbS->Status < RT_ELEMENTS(s_apszStatuses) ? pUsbS->Status : RT_ELEMENTS(s_apszStatuses) - 1]));
684	if (pDev)
685	pDev->Urb.u8ScsiCmd = 0xff;
686	}
687	else if ( fComplete
688	&& pUrb->enmType == VUSBXFERTYPE_BULK
689	&& pUrb->enmDir == VUSBDIRECTION_IN
690	&& pDev
691	&& pDev->Urb.u8ScsiCmd != 0xff)
692	{
693	const uint8_t *pb = pUrb->abData;
694	switch (pDev->Urb.u8ScsiCmd)
695	{
696	case 0x03: /* REQUEST_SENSE */
697	Log(("URB: %*s: SCSI: RESPONSE: REQUEST_SENSE (%s)\n",
698	s_cchMaxMsg, pszMsg, pb[0] & 7 ? "scsi compliant" : "not scsi compliant"));
699	Log(("URB: %*s: SCSI: ErrCd=%#RX8 (%s) Seg=%#RX8 Filemark=%d EOM=%d ILI=%d\n",
700	s_cchMaxMsg, pszMsg, pb[0] & 0x7f, GetScsiErrCd(pb[0] & 0x7f), pb[1],
701	pb[2] >> 7, !!(pb[2] & RT_BIT(6)), !!(pb[2] & RT_BIT(5))));
702	Log(("URB: %*s: SCSI: SenseKey=%#x ASC=%#RX8 ASCQ=%#RX8 : %s\n",
703	s_cchMaxMsg, pszMsg, pb[2] & 0xf, pb[12], pb[13],
704	GetScsiKCQ(pb[2] & 0xf, pb[12], pb[13])));
705	/** @todo more later */
706	break;
707
708	case 0x12: /* INQUIRY. */
709	{
710	unsigned cb = pb[4] + 5;
711	Log(("URB: %*s: SCSI: RESPONSE: INQUIRY\n"
712	"URB: %*s: SCSI: PeripheralQualifier=%d PeripheralType=%#RX8 RMB=%d DevTypeMod=%#RX8\n",
713	s_cchMaxMsg, pszMsg, s_cchMaxMsg, pszMsg,
714	pb[0] >> 5, pb[0] & 0x1f, pb[1] >> 7, pb[1] & 0x7f));
715	Log(("URB: %*s: SCSI: ISOVer=%d ECMAVer=%d ANSIVer=%d\n",
716	s_cchMaxMsg, pszMsg, pb[2] >> 6, (pb[2] >> 3) & 7, pb[2] & 7));
717	Log(("URB: %*s: SCSI: AENC=%d TrmlOP=%d RespDataFmt=%d (%s) AddLen=%d\n",
718	s_cchMaxMsg, pszMsg, pb[3] >> 7, (pb[3] >> 6) & 1,
719	pb[3] & 0xf, pb[3] & 0xf ? "legacy" : "scsi", pb[4]));
720	if (cb < 8)
721	break;
722	Log(("URB: %*s: SCSI: RelAdr=%d WBus32=%d WBus16=%d Sync=%d Linked=%d CmdQue=%d SftRe=%d\n",
723	s_cchMaxMsg, pszMsg, pb[7] >> 7, !!(pb[7] >> 6), !!(pb[7] >> 5), !!(pb[7] >> 4),
724	!!(pb[7] >> 3), !!(pb[7] >> 1), pb[7] & 1));
725	if (cb < 16)
726	break;
727	Log(("URB: %*s: SCSI: VendorId=%.8s\n", s_cchMaxMsg, pszMsg, &pb[8]));
728	if (cb < 32)
729	break;
730	Log(("URB: %*s: SCSI: ProductId=%.16s\n", s_cchMaxMsg, pszMsg, &pb[16]));
731	if (cb < 36)
732	break;
733	Log(("URB: %*s: SCSI: ProdRevLvl=%.4s\n", s_cchMaxMsg, pszMsg, &pb[32]));
734	if (cb > 36)
735	Log(("URB: %s: SCSI: VendorSpecific=%.s\n",
736	s_cchMaxMsg, pszMsg, RT_MIN(cb - 36, 20), &pb[36]));
737	if (cb > 96)
738	Log(("URB: %s: SCSI: VendorParam=%.Rhxs\n",
739	s_cchMaxMsg, pszMsg, cb - 96, &pb[96]));
740	break;
741	}
742
743	case 0x25: /* Read Capacity(6) command. */
744	Log(("URB: %*s: SCSI: RESPONSE: READ_CAPACITY\n"
745	"URB: %*s: SCSI: LBA=%#RX32 BlockLen=%#RX32\n",
746	s_cchMaxMsg, pszMsg, s_cchMaxMsg, pszMsg,
747	RT_MAKE_U32_FROM_U8(pb[3], pb[2], pb[1], pb[0]),
748	RT_MAKE_U32_FROM_U8(pb[7], pb[6], pb[5], pb[4])));
749	break;
750	}
751
752	pDev->Urb.u8ScsiCmd = 0xff;
753	}
754
755	/*
756	* The Quickcam control pipe.
757	*/
758	if ( pSetup
759	&& ((pSetup->bmRequestType >> 5) & 0x3) >= 2 /* vendor */
760	&& (fComplete \|\| !(pSetup->bmRequestType >> 7))
761	&& pDev
762	&& pDev->pDescCache
763	&& pDev->pDescCache->pDevice
764	&& pDev->pDescCache->pDevice->idVendor == 0x046d
765	&& ( pDev->pDescCache->pDevice->idProduct == 0x8f6
766	\|\| pDev->pDescCache->pDevice->idProduct == 0x8f5
767	\|\| pDev->pDescCache->pDevice->idProduct == 0x8f0)
768	)
769	{
770	pbData = (const uint8_t *)(pSetup + 1);
771	cbData = pUrb->cbData - sizeof(*pSetup);
772
773	if ( pSetup->bRequest == 0x04
774	&& pSetup->wIndex == 0
775	&& (cbData == 1 \|\| cbData == 2))
776	{
777	/* the value */
778	unsigned uVal = pbData[0];
779	if (cbData > 1)
780	uVal \|= (unsigned)pbData[1] << 8;
781
782	const char *pszReg = NULL;
783	switch (pSetup->wValue)
784	{
785	case 0: pszReg = "i2c init"; break;
786	case 0x0423: pszReg = "STV_REG23"; break;
787	case 0x0509: pszReg = "RED something"; break;
788	case 0x050a: pszReg = "GREEN something"; break;
789	case 0x050b: pszReg = "BLUE something"; break;
790	case 0x143f: pszReg = "COMMIT? INIT DONE?"; break;
791	case 0x1440: pszReg = "STV_ISO_ENABLE"; break;
792	case 0x1442: pszReg = uVal & (RT_BIT(7)\|RT_BIT(5)) ? "BUTTON PRESSED" : "BUTTON" ; break;
793	case 0x1443: pszReg = "STV_SCAN_RATE"; break;
794	case 0x1445: pszReg = "LED?"; break;
795	case 0x1500: pszReg = "STV_REG00"; break;
796	case 0x1501: pszReg = "STV_REG01"; break;
797	case 0x1502: pszReg = "STV_REG02"; break;
798	case 0x1503: pszReg = "STV_REG03"; break;
799	case 0x1504: pszReg = "STV_REG04"; break;
800	case 0x15c1: pszReg = "STV_ISO_SIZE"; break;
801	case 0x15c3: pszReg = "STV_Y_CTRL"; break;
802	case 0x1680: pszReg = "STV_X_CTRL"; break;
803	case 0xe00a: pszReg = "ProductId"; break;
804	default: pszReg = "[no clue]"; break;
805	}
806	if (pszReg)
807	Log(("URB: %*s: QUICKCAM: %s %#x (%d) %s '%s' (%#x)\n",
808	s_cchMaxMsg, pszMsg,
809	(pSetup->bmRequestType >> 7) ? "read" : "write", uVal, uVal, (pSetup->bmRequestType >> 7) ? "from" : "to",
810	pszReg, pSetup->wValue));
811	}
812	else if (cbData)
813	Log(("URB: %s: QUICKCAM: Unknown request: bRequest=%#x bmRequestType=%#x wValue=%#x wIndex=%#x: %.Rhxs\n", s_cchMaxMsg, pszMsg,
814	pSetup->bRequest, pSetup->bmRequestType, pSetup->wValue, pSetup->wIndex, cbData, pbData));
815	else
816	Log(("URB: %*s: QUICKCAM: Unknown request: bRequest=%#x bmRequestType=%#x wValue=%#x wIndex=%#x: (no data)\n", s_cchMaxMsg, pszMsg,
817	pSetup->bRequest, pSetup->bmRequestType, pSetup->wValue, pSetup->wIndex));
818	}
819
820	#if 1
821	if ( cbData /** @todo Fix RTStrFormatV to communicate .* so formatter doesn't apply defaults when cbData=0. */
822	&& (fComplete
823	? pUrb->enmDir != VUSBDIRECTION_OUT
824	: pUrb->enmDir == VUSBDIRECTION_OUT))
825	Log3(("%16.*Rhxd\n", cbData, pbData));
826	#endif
827	if (pUrb->enmType == VUSBXFERTYPE_MSG && pUrb->pVUsb && pUrb->pVUsb->pCtrlUrb)
828	vusbUrbTrace(pUrb->pVUsb->pCtrlUrb, "NESTED MSG", fComplete);
829	}
830	#endif /* LOG_ENABLED */
831

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

source: vbox/trunk/src/VBox/Devices/USB/VUSBUrbTrace.cpp@ 100512

Download in other formats: