VirtualBox

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

Last change on this file was 98103, checked in by vboxsync, 16 months 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
50DECLINLINE(const char *) GetScsiErrCd(uint8_t ScsiErr)
51{
52 switch (ScsiErr)
53 {
54 case 0: return "?";
55 }
56 return "?";
57}
58
59DECLINLINE(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
97DECLHIDDEN(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
119DECLHIDDEN(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
134DECLHIDDEN(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 */
156DECLHIDDEN(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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use