VirtualBox

source: vbox/trunk/src/VBox/Devices/USB/VUSBUrb.cpp@ 52934

Last change on this file since 52934 was 52881, checked in by vboxsync, 10 years ago

Devices/USB: Fix race when resetting USB devices causing a crash later

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 81.6 KB
Line 
1/* $Id: VUSBUrb.cpp 52881 2014-09-29 09:22:22Z vboxsync $ */
2/** @file
3 * Virtual USB - URBs.
4 */
5
6/*
7 * Copyright (C) 2006-2010 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/*******************************************************************************
19* Header Files *
20*******************************************************************************/
21#define LOG_GROUP LOG_GROUP_DRV_VUSB
22#include <VBox/vmm/pdm.h>
23#include <VBox/vmm/vmapi.h>
24#include <VBox/err.h>
25#include <iprt/alloc.h>
26#include <VBox/log.h>
27#include <iprt/time.h>
28#include <iprt/thread.h>
29#include <iprt/semaphore.h>
30#include <iprt/string.h>
31#include <iprt/assert.h>
32#include <iprt/asm.h>
33#include <iprt/env.h>
34#include "VUSBInternal.h"
35
36
37
38/*******************************************************************************
39* Global Variables *
40*******************************************************************************/
41/** Strings for the CTLSTAGE enum values. */
42const char * const g_apszCtlStates[4] =
43{
44 "SETUP",
45 "DATA",
46 "STATUS",
47 "N/A"
48};
49
50
51/*******************************************************************************
52* Internal Functions *
53*******************************************************************************/
54static PVUSBCTRLEXTRA vusbMsgAllocExtraData(PVUSBURB pUrb);
55
56
57#ifdef LOG_ENABLED
58DECLINLINE(const char *) vusbUrbStatusName(VUSBSTATUS enmStatus)
59{
60 /** Strings for the URB statuses. */
61 static const char * const s_apszNames[] =
62 {
63 "OK",
64 "STALL",
65 "ERR_DNR",
66 "ERR_CRC",
67 "DATA_UNDERRUN",
68 "DATA_OVERRUN",
69 "NOT_ACCESSED",
70 "7", "8", "9", "10", "11", "12", "13", "14", "15"
71 };
72
73 return enmStatus < (int)RT_ELEMENTS(s_apszNames)
74 ? s_apszNames[enmStatus]
75 : enmStatus == VUSBSTATUS_INVALID
76 ? "INVALID"
77 : "??";
78}
79
80DECLINLINE(const char *) vusbUrbDirName(VUSBDIRECTION enmDir)
81{
82 /** Strings for the URB directions. */
83 static const char * const s_apszNames[] =
84 {
85 "setup",
86 "in",
87 "out"
88 };
89
90 return enmDir < (int)RT_ELEMENTS(s_apszNames)
91 ? s_apszNames[enmDir]
92 : "??";
93}
94
95DECLINLINE(const char *) vusbUrbTypeName(VUSBXFERTYPE enmType)
96{
97 /** Strings for the URB types. */
98 static const char * const s_apszName[] =
99 {
100 "control-part",
101 "isochronous",
102 "bulk",
103 "interrupt",
104 "control"
105 };
106
107 return enmType < (int)RT_ELEMENTS(s_apszName)
108 ? s_apszName[enmType]
109 : "??";
110}
111
112DECLINLINE(const char *) GetScsiErrCd(uint8_t ScsiErr)
113{
114 switch (ScsiErr)
115 {
116 case 0: return "?";
117 }
118 return "?";
119}
120
121DECLINLINE(const char *) GetScsiKCQ(uint8_t Key, uint8_t ASC, uint8_t ASCQ)
122{
123 switch (Key)
124 {
125 case 0:
126 switch (RT_MAKE_U16(ASC, ASCQ))
127 {
128 case RT_MAKE_U16(0x00, 0x00): return "No error";
129 }
130 break;
131
132 case 1:
133 return "Soft Error";
134
135 case 2:
136 return "Not Ready";
137
138 case 3:
139 return "Medium Error";
140
141 case 4:
142 return "Hard Error";
143
144 case 5:
145 return "Illegal Request";
146
147 case 6:
148 return "Unit Attention";
149
150 case 7:
151 return "Write Protected";
152
153 case 0xb:
154 return "Aborted Command";
155 }
156 return "?";
157}
158
159
160/**
161 * Logs an URB.
162 *
163 * Note that pUrb->pUsbIns, pUrb->VUsb.pDev and pUrb->VUsb.pDev->pUsbIns can all be NULL.
164 */
165void vusbUrbTrace(PVUSBURB pUrb, const char *pszMsg, bool fComplete)
166{
167 PVUSBDEV pDev = pUrb->VUsb.pDev; /* Can be NULL when called from usbProxyConstruct and friends. */
168 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
169 const uint8_t *pbData = pUrb->abData;
170 uint32_t cbData = pUrb->cbData;
171 PCVUSBSETUP pSetup = NULL;
172 bool fDescriptors = false;
173 static size_t s_cchMaxMsg = 10;
174 size_t cchMsg = strlen(pszMsg);
175 if (cchMsg > s_cchMaxMsg)
176 s_cchMaxMsg = cchMsg;
177
178 Log(("%s: %*s: pDev=%p[%s] rc=%s a=%i e=%u d=%s t=%s cb=%#x(%d) Ed=%08x cTds=%d Td0=%08x ts=%RU64 (%RU64 ns ago) %s\n",
179 pUrb->pszDesc, s_cchMaxMsg, pszMsg,
180 pDev,
181 pUrb->pUsbIns ? pUrb->pUsbIns->pszName : "",
182 vusbUrbStatusName(pUrb->enmStatus),
183 pDev ? pDev->u8Address : -1,
184 pUrb->EndPt,
185 vusbUrbDirName(pUrb->enmDir),
186 vusbUrbTypeName(pUrb->enmType),
187 pUrb->cbData,
188 pUrb->cbData,
189 pUrb->Hci.EdAddr,
190 pUrb->Hci.cTds,
191 pUrb->Hci.cTds ? pUrb->Hci.paTds[0].TdAddr : ~(uint32_t)0,
192 pUrb->VUsb.u64SubmitTS,
193 RTTimeNanoTS() - pUrb->VUsb.u64SubmitTS,
194 pUrb->fShortNotOk ? "ShortNotOk" : "ShortOk"));
195
196#ifndef DEBUG_bird
197 if ( pUrb->enmType == VUSBXFERTYPE_CTRL
198 && pUrb->enmStatus == VUSBSTATUS_OK)
199 return;
200#endif
201
202 if ( pUrb->enmType == VUSBXFERTYPE_MSG
203 || ( pUrb->enmDir == VUSBDIRECTION_SETUP
204 && pUrb->enmType == VUSBXFERTYPE_CTRL
205 && cbData))
206 {
207 static const char * const s_apszReqDirs[] = {"host2dev", "dev2host"};
208 static const char * const s_apszReqTypes[] = {"std", "class", "vendor", "reserved"};
209 static const char * const s_apszReqRecipients[] = {"dev", "if", "endpoint", "other"};
210 static const char * const s_apszRequests[] =
211 {
212 "GET_STATUS", "CLEAR_FEATURE", "2?", "SET_FEATURE",
213 "4?", "SET_ADDRESS", "GET_DESCRIPTOR", "SET_DESCRIPTOR",
214 "GET_CONFIGURATION", "SET_CONFIGURATION", "GET_INTERFACE", "SET_INTERFACE",
215 "SYNCH_FRAME"
216 };
217 pSetup = (PVUSBSETUP)pUrb->abData;
218 pbData += sizeof(*pSetup);
219 cbData -= sizeof(*pSetup);
220
221 Log(("%s: %*s: CTRL: bmRequestType=0x%.2x (%s %s %s) bRequest=0x%.2x (%s) wValue=0x%.4x wIndex=0x%.4x wLength=0x%.4x\n",
222 pUrb->pszDesc, s_cchMaxMsg, pszMsg,
223 pSetup->bmRequestType, s_apszReqDirs[pSetup->bmRequestType >> 7], s_apszReqTypes[(pSetup->bmRequestType >> 5) & 0x3],
224 (unsigned)(pSetup->bmRequestType & 0xf) < RT_ELEMENTS(s_apszReqRecipients) ? s_apszReqRecipients[pSetup->bmRequestType & 0xf] : "??",
225 pSetup->bRequest, pSetup->bRequest < RT_ELEMENTS(s_apszRequests) ? s_apszRequests[pSetup->bRequest] : "??",
226 pSetup->wValue, pSetup->wIndex, pSetup->wLength));
227
228 if ( pSetup->bRequest == VUSB_REQ_GET_DESCRIPTOR
229 && fComplete
230 && pUrb->enmStatus == VUSBSTATUS_OK
231 && ((pSetup->bmRequestType >> 5) & 0x3) < 2 /* vendor */)
232 fDescriptors = true;
233 }
234 else if ( fComplete
235 && pUrb->enmDir == VUSBDIRECTION_IN
236 && pUrb->enmType == VUSBXFERTYPE_CTRL
237 && pUrb->enmStatus == VUSBSTATUS_OK
238 && pPipe->pCtrl
239 && pPipe->pCtrl->enmStage == CTLSTAGE_DATA
240 && cbData > 0)
241 {
242 pSetup = pPipe->pCtrl->pMsg;
243 if (pSetup->bRequest == VUSB_REQ_GET_DESCRIPTOR)
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->VUsb.pCtrlUrb)
828 vusbUrbTrace(pUrb->VUsb.pCtrlUrb, "NESTED MSG", fComplete);
829}
830#endif /* LOG_ENABLED */
831
832
833/**
834 * Complete a SETUP stage URB.
835 *
836 * This is used both for dev2host and host2dev kind of transfers.
837 * It is used by both the sync and async control paths.
838 */
839static void vusbMsgSetupCompletion(PVUSBURB pUrb)
840{
841 PVUSBDEV pDev = pUrb->VUsb.pDev;
842 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
843 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
844 PVUSBSETUP pSetup = pExtra->pMsg;
845
846 LogFlow(("%s: vusbMsgSetupCompletion: cbData=%d wLength=%#x cbLeft=%d pPipe=%p stage %s->DATA\n",
847 pUrb->pszDesc, pUrb->cbData, pSetup->wLength, pExtra->cbLeft, pPipe, g_apszCtlStates[pExtra->enmStage])); NOREF(pSetup);
848 pExtra->enmStage = CTLSTAGE_DATA;
849 pUrb->enmStatus = VUSBSTATUS_OK;
850}
851
852/**
853 * Complete a DATA stage URB.
854 *
855 * This is used both for dev2host and host2dev kind of transfers.
856 * It is used by both the sync and async control paths.
857 */
858static void vusbMsgDataCompletion(PVUSBURB pUrb)
859{
860 PVUSBDEV pDev = pUrb->VUsb.pDev;
861 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
862 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
863 PVUSBSETUP pSetup = pExtra->pMsg;
864
865 LogFlow(("%s: vusbMsgDataCompletion: cbData=%d wLength=%#x cbLeft=%d pPipe=%p stage DATA\n",
866 pUrb->pszDesc, pUrb->cbData, pSetup->wLength, pExtra->cbLeft, pPipe)); NOREF(pSetup);
867
868 pUrb->enmStatus = VUSBSTATUS_OK;
869}
870
871/**
872 * Complete a STATUS stage URB.
873 *
874 * This is used both for dev2host and host2dev kind of transfers.
875 * It is used by both the sync and async control paths.
876 */
877static void vusbMsgStatusCompletion(PVUSBURB pUrb)
878{
879 PVUSBDEV pDev = pUrb->VUsb.pDev;
880 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
881 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
882
883 if (pExtra->fOk)
884 {
885 /*
886 * vusbDevStdReqSetAddress requests are deferred.
887 */
888 if (pDev->u8NewAddress != VUSB_INVALID_ADDRESS)
889 {
890 vusbDevSetAddress(pDev, pDev->u8NewAddress);
891 pDev->u8NewAddress = VUSB_INVALID_ADDRESS;
892 }
893
894 LogFlow(("%s: vusbMsgStatusCompletion: pDev=%p[%s] pPipe=%p err=OK stage %s->SETUP\n",
895 pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pPipe, g_apszCtlStates[pExtra->enmStage]));
896 pUrb->enmStatus = VUSBSTATUS_OK;
897 }
898 else
899 {
900 LogFlow(("%s: vusbMsgStatusCompletion: pDev=%p[%s] pPipe=%p err=STALL stage %s->SETUP\n",
901 pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pPipe, g_apszCtlStates[pExtra->enmStage]));
902 pUrb->enmStatus = VUSBSTATUS_STALL;
903 }
904
905 /*
906 * Done with this message sequence.
907 */
908 pExtra->pbCur = NULL;
909 pExtra->enmStage = CTLSTAGE_SETUP;
910}
911
912/**
913 * This is a worker function for vusbMsgCompletion and
914 * vusbMsgSubmitSynchronously used to complete the original URB.
915 *
916 * @param pUrb The URB originating from the HCI.
917 */
918static void vusbCtrlCompletion(PVUSBURB pUrb)
919{
920 PVUSBDEV pDev = pUrb->VUsb.pDev;
921 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
922 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
923 LogFlow(("%s: vusbCtrlCompletion: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName));
924
925 switch (pExtra->enmStage)
926 {
927 case CTLSTAGE_SETUP:
928 vusbMsgSetupCompletion(pUrb);
929 break;
930 case CTLSTAGE_DATA:
931 vusbMsgDataCompletion(pUrb);
932 break;
933 case CTLSTAGE_STATUS:
934 vusbMsgStatusCompletion(pUrb);
935 break;
936 }
937}
938
939/**
940 * Called from vusbUrbCompletionRh when it encounters a
941 * message type URB.
942 *
943 * @param pUrb The URB within the control pipe extra state data.
944 */
945static void vusbMsgCompletion(PVUSBURB pUrb)
946{
947 PVUSBDEV pDev = pUrb->VUsb.pDev;
948 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
949
950 RTCritSectEnter(&pPipe->CritSectCtrl);
951 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
952
953#ifdef LOG_ENABLED
954 LogFlow(("%s: vusbMsgCompletion: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName));
955 vusbUrbTrace(pUrb, "vusbMsgCompletion", true);
956#endif
957 Assert(&pExtra->Urb == pUrb);
958
959
960 if (pUrb->enmStatus == VUSBSTATUS_OK)
961 pExtra->fOk = true;
962 else
963 pExtra->fOk = false;
964 pExtra->cbLeft = pUrb->cbData - sizeof(VUSBSETUP);
965
966 /*
967 * Complete the original URB.
968 */
969 PVUSBURB pCtrlUrb = pUrb->VUsb.pCtrlUrb;
970 pCtrlUrb->enmState = VUSBURBSTATE_REAPED;
971 vusbCtrlCompletion(pCtrlUrb);
972
973 /*
974 * 'Free' the message URB, i.e. put it back to the allocated state.
975 */
976 Assert( pUrb->enmState == VUSBURBSTATE_REAPED
977 || pUrb->enmState == VUSBURBSTATE_CANCELLED);
978 if (pUrb->enmState != VUSBURBSTATE_CANCELLED)
979 pUrb->enmState = VUSBURBSTATE_ALLOCATED;
980 RTCritSectLeave(&pPipe->CritSectCtrl);
981
982 /* Complete the original control URB on the root hub now. */
983 vusbUrbCompletionRh(pCtrlUrb);
984}
985
986/**
987 * Deal with URB errors, talking thru the RH to the HCI.
988 *
989 * @returns true if it could be retried.
990 * @returns false if it should be completed with failure.
991 * @param pUrb The URB in question.
992 */
993int vusbUrbErrorRh(PVUSBURB pUrb)
994{
995 PVUSBDEV pDev = pUrb->VUsb.pDev;
996 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
997 AssertPtrReturn(pRh, VERR_VUSB_DEVICE_NOT_ATTACHED);
998 LogFlow(("%s: vusbUrbErrorRh: pDev=%p[%s] rh=%p\n", pUrb->pszDesc, pDev, pDev->pUsbIns ? pDev->pUsbIns->pszName : "", pRh));
999 return pRh->pIRhPort->pfnXferError(pRh->pIRhPort, pUrb);
1000}
1001
1002/**
1003 * Does URB completion on roothub level.
1004 *
1005 * @param pUrb The URB to complete.
1006 */
1007void vusbUrbCompletionRh(PVUSBURB pUrb)
1008{
1009 LogFlow(("%s: vusbUrbCompletionRh: type=%s status=%s\n",
1010 pUrb->pszDesc, vusbUrbTypeName(pUrb->enmType), vusbUrbStatusName(pUrb->enmStatus)));
1011 AssertMsg( pUrb->enmState == VUSBURBSTATE_REAPED
1012 || pUrb->enmState == VUSBURBSTATE_CANCELLED, ("%d\n", pUrb->enmState));
1013
1014
1015#ifdef VBOX_WITH_STATISTICS
1016 /*
1017 * Total and per-type submit statistics.
1018 */
1019 PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->VUsb.pDev);
1020 AssertPtrReturnVoid(pRh);
1021 if (pUrb->enmType != VUSBXFERTYPE_MSG)
1022 {
1023 Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));
1024
1025 if ( pUrb->enmStatus == VUSBSTATUS_OK
1026 || pUrb->enmStatus == VUSBSTATUS_DATA_UNDERRUN
1027 || pUrb->enmStatus == VUSBSTATUS_DATA_OVERRUN)
1028 {
1029 if (pUrb->enmType == VUSBXFERTYPE_ISOC)
1030 {
1031 for (unsigned i = 0; i < pUrb->cIsocPkts; i++)
1032 {
1033 const unsigned cb = pUrb->aIsocPkts[i].cb;
1034 if (cb)
1035 {
1036 STAM_COUNTER_ADD(&pRh->Total.StatActBytes, cb);
1037 STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActBytes, cb);
1038 STAM_COUNTER_ADD(&pRh->aStatIsocDetails[i].Bytes, cb);
1039 if (pUrb->enmDir == VUSBDIRECTION_IN)
1040 {
1041 STAM_COUNTER_ADD(&pRh->Total.StatActReadBytes, cb);
1042 STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActReadBytes, cb);
1043 }
1044 else
1045 {
1046 STAM_COUNTER_ADD(&pRh->Total.StatActWriteBytes, cb);
1047 STAM_COUNTER_ADD(&pRh->aTypes[VUSBXFERTYPE_ISOC].StatActWriteBytes, cb);
1048 }
1049 STAM_COUNTER_INC(&pRh->StatIsocActPkts);
1050 STAM_COUNTER_INC(&pRh->StatIsocActReadPkts);
1051 }
1052 STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Pkts);
1053 switch (pUrb->aIsocPkts[i].enmStatus)
1054 {
1055 case VUSBSTATUS_OK:
1056 if (cb) STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Ok);
1057 else STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Ok0); break;
1058 case VUSBSTATUS_DATA_UNDERRUN:
1059 if (cb) STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataUnderrun);
1060 else STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataUnderrun0); break;
1061 case VUSBSTATUS_DATA_OVERRUN: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].DataOverrun); break;
1062 case VUSBSTATUS_NOT_ACCESSED: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].NotAccessed); break;
1063 default: STAM_COUNTER_INC(&pRh->aStatIsocDetails[i].Misc); break;
1064 }
1065 }
1066 }
1067 else
1068 {
1069 STAM_COUNTER_ADD(&pRh->Total.StatActBytes, pUrb->cbData);
1070 STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActBytes, pUrb->cbData);
1071 if (pUrb->enmDir == VUSBDIRECTION_IN)
1072 {
1073 STAM_COUNTER_ADD(&pRh->Total.StatActReadBytes, pUrb->cbData);
1074 STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActReadBytes, pUrb->cbData);
1075 }
1076 else
1077 {
1078 STAM_COUNTER_ADD(&pRh->Total.StatActWriteBytes, pUrb->cbData);
1079 STAM_COUNTER_ADD(&pRh->aTypes[pUrb->enmType].StatActWriteBytes, pUrb->cbData);
1080 }
1081 }
1082 }
1083 else
1084 {
1085 /* (Note. this also counts the cancelled packets) */
1086 STAM_COUNTER_INC(&pRh->Total.StatUrbsFailed);
1087 STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsFailed);
1088 }
1089 }
1090#endif /* VBOX_WITH_STATISTICS */
1091
1092 /*
1093 * Msg transfers are special virtual transfers associated with
1094 * vusb, not the roothub
1095 */
1096 switch (pUrb->enmType)
1097 {
1098 case VUSBXFERTYPE_MSG:
1099 vusbMsgCompletion(pUrb);
1100 return;
1101 case VUSBXFERTYPE_ISOC:
1102 /* Don't bother with error callback for isochronous URBs. */
1103 break;
1104
1105#if 1 /** @todo r=bird: OHCI say "If the Transfer Descriptor is being
1106 * retired because of an error, the Host Controller must update
1107 * the Halt bit of the Endpoint Descriptor."
1108 *
1109 * So, I'll subject all transfertypes to the same halt stuff now. It could
1110 * just happen to fix the logitech disconnect trap in win2k.
1111 */
1112 default:
1113#endif
1114 case VUSBXFERTYPE_BULK:
1115 if (pUrb->enmStatus != VUSBSTATUS_OK)
1116 vusbUrbErrorRh(pUrb);
1117 break;
1118 }
1119#ifdef LOG_ENABLED
1120 vusbUrbTrace(pUrb, "vusbUrbCompletionRh", true);
1121#endif
1122#ifndef VBOX_WITH_STATISTICS
1123 PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->VUsb.pDev);
1124 AssertPtrReturnVoid(pRh);
1125#endif
1126
1127 pRh->pIRhPort->pfnXferCompletion(pRh->pIRhPort, pUrb);
1128 if (pUrb->enmState == VUSBURBSTATE_REAPED)
1129 {
1130 LogFlow(("%s: vusbUrbCompletionRh: Freeing URB\n", pUrb->pszDesc));
1131 pUrb->VUsb.pfnFree(pUrb);
1132 }
1133}
1134
1135
1136/**
1137 * Certain control requests must not ever be forwarded to the device because
1138 * they are required by the vusb core in order to maintain the vusb internal
1139 * data structures.
1140 */
1141DECLINLINE(bool) vusbUrbIsRequestSafe(PCVUSBSETUP pSetup, PVUSBURB pUrb)
1142{
1143 if ((pSetup->bmRequestType & VUSB_REQ_MASK) != VUSB_REQ_STANDARD)
1144 return true;
1145
1146 switch (pSetup->bRequest)
1147 {
1148 case VUSB_REQ_CLEAR_FEATURE:
1149 return pUrb->EndPt != 0 /* not default control pipe */
1150 || pSetup->wValue != 0 /* not ENDPOINT_HALT */
1151 || !pUrb->pUsbIns->pReg->pfnUsbClearHaltedEndpoint; /* not special need for backend */
1152 case VUSB_REQ_SET_ADDRESS:
1153 case VUSB_REQ_SET_CONFIGURATION:
1154 case VUSB_REQ_GET_CONFIGURATION:
1155 case VUSB_REQ_SET_INTERFACE:
1156 case VUSB_REQ_GET_INTERFACE:
1157 return false;
1158
1159 /*
1160 * If the device wishes it, we'll use the cached device and
1161 * configuration descriptors. (We return false when we want to use the
1162 * cache. Yeah, it's a bit weird to read.)
1163 */
1164 case VUSB_REQ_GET_DESCRIPTOR:
1165 if ( !pUrb->VUsb.pDev->pDescCache->fUseCachedDescriptors
1166 || (pSetup->bmRequestType & VUSB_RECIP_MASK) != VUSB_TO_DEVICE)
1167 return true;
1168 switch (pSetup->wValue >> 8)
1169 {
1170 case VUSB_DT_DEVICE:
1171 case VUSB_DT_CONFIG:
1172 return false;
1173 case VUSB_DT_STRING:
1174 return !pUrb->VUsb.pDev->pDescCache->fUseCachedStringsDescriptors;
1175 default:
1176 return true;
1177 }
1178
1179 default:
1180 return true;
1181 }
1182}
1183
1184
1185/**
1186 * Queues an URB for asynchronous transfer.
1187 * A list of asynchronous URBs is kept by the roothub.
1188 *
1189 * @returns VBox status code (from pfnUrbQueue).
1190 * @param pUrb The URB.
1191 */
1192int vusbUrbQueueAsyncRh(PVUSBURB pUrb)
1193{
1194#ifdef LOG_ENABLED
1195 vusbUrbTrace(pUrb, "vusbUrbQueueAsyncRh", false);
1196#endif
1197
1198 /* Immediately return in case of error.
1199 * XXX There is still a race: The Rh might vanish after this point! */
1200 PVUSBDEV pDev = pUrb->VUsb.pDev;
1201 PVUSBROOTHUB pRh = vusbDevGetRh(pDev);
1202 if (!pRh)
1203 {
1204 Log(("vusbUrbQueueAsyncRh returning VERR_OBJECT_DESTROYED\n"));
1205 return VERR_OBJECT_DESTROYED;
1206 }
1207
1208 RTCritSectEnter(&pDev->CritSectAsyncUrbs);
1209 int rc = pUrb->pUsbIns->pReg->pfnUrbQueue(pUrb->pUsbIns, pUrb);
1210 if (RT_FAILURE(rc))
1211 {
1212 LogFlow(("%s: vusbUrbQueueAsyncRh: returns %Rrc (queue_urb)\n", pUrb->pszDesc, rc));
1213 RTCritSectLeave(&pDev->CritSectAsyncUrbs);
1214 return rc;
1215 }
1216
1217 ASMAtomicIncU32(&pDev->aPipes[pUrb->EndPt].async);
1218
1219 /* Queue the pUrb on the roothub */
1220 pUrb->VUsb.pNext = pDev->pAsyncUrbHead;
1221 if (pDev->pAsyncUrbHead)
1222 pDev->pAsyncUrbHead->VUsb.ppPrev = &pUrb->VUsb.pNext;
1223 pDev->pAsyncUrbHead = pUrb;
1224 pUrb->VUsb.ppPrev = &pDev->pAsyncUrbHead;
1225 RTCritSectLeave(&pDev->CritSectAsyncUrbs);
1226
1227 return VINF_SUCCESS;
1228}
1229
1230
1231/**
1232 * Send a control message *synchronously*.
1233 * @return
1234 */
1235static void vusbMsgSubmitSynchronously(PVUSBURB pUrb, bool fSafeRequest)
1236{
1237 PVUSBDEV pDev = pUrb->VUsb.pDev;
1238 Assert(pDev);
1239 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
1240 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
1241 PVUSBSETUP pSetup = pExtra->pMsg;
1242 LogFlow(("%s: vusbMsgSubmitSynchronously: pDev=%p[%s]\n", pUrb->pszDesc, pDev, pDev->pUsbIns ? pDev->pUsbIns->pszName : ""));
1243
1244 uint8_t *pbData = (uint8_t *)pExtra->pMsg + sizeof(*pSetup);
1245 uint32_t cbData = pSetup->wLength;
1246 bool fOk = false;
1247 if (!fSafeRequest)
1248 fOk = vusbDevStandardRequest(pDev, pUrb->EndPt, pSetup, pbData, &cbData);
1249 else
1250 AssertMsgFailed(("oops\n"));
1251
1252 pUrb->enmState = VUSBURBSTATE_REAPED;
1253 if (fOk)
1254 {
1255 pSetup->wLength = cbData;
1256 pUrb->enmStatus = VUSBSTATUS_OK;
1257 pExtra->fOk = true;
1258 }
1259 else
1260 {
1261 pUrb->enmStatus = VUSBSTATUS_STALL;
1262 pExtra->fOk = false;
1263 }
1264 pExtra->cbLeft = cbData; /* used by IN only */
1265
1266 vusbCtrlCompletion(pUrb);
1267 vusbUrbCompletionRh(pUrb);
1268
1269 /*
1270 * 'Free' the message URB, i.e. put it back to the allocated state.
1271 */
1272 pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
1273}
1274
1275/**
1276 * Callback for dealing with device reset.
1277 */
1278void vusbMsgResetExtraData(PVUSBCTRLEXTRA pExtra)
1279{
1280 if (!pExtra)
1281 return;
1282 pExtra->enmStage = CTLSTAGE_SETUP;
1283 if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
1284 pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
1285}
1286
1287
1288/**
1289 * Callback to free a cancelled message URB.
1290 *
1291 * This is yet another place we're we have to performance acrobatics to
1292 * deal with cancelled URBs. sigh.
1293 *
1294 * The deal here is that we never free message URBs since they are integrated
1295 * into the message pipe state. But since cancel can leave URBs unreaped and in
1296 * a state which require them not to be freed, we'll have to do two things.
1297 * First, if a new message URB is processed we'll have to get a new message
1298 * pipe state. Second, we cannot just free the damn state structure because
1299 * that might lead to heap corruption since it might still be in-flight.
1300 *
1301 * The URB embedded into the message pipe control structure will start in an
1302 * ALLOCATED state. When submitted it will be go to the IN-FLIGHT state. When
1303 * reaped it will go from REAPED to ALLOCATED. When completed in the CANCELLED
1304 * state it will remain in that state (as does normal URBs).
1305 *
1306 * If a new message urb comes up while it's in the CANCELLED state, we will
1307 * orphan it and it will be freed here in vusbMsgFreeUrb. We indicate this
1308 * by setting VUsb.pvFreeCtx to NULL.
1309 *
1310 * If we have to free the message state structure because of device destruction,
1311 * configuration changes, or similar, we will orphan the message pipe state in
1312 * the same way by setting VUsb.pvFreeCtx to NULL and let this function free it.
1313 *
1314 * @param pUrb
1315 */
1316static DECLCALLBACK(void) vusbMsgFreeUrb(PVUSBURB pUrb)
1317{
1318 vusbUrbAssert(pUrb);
1319 PVUSBCTRLEXTRA pExtra = (PVUSBCTRLEXTRA)((uint8_t *)pUrb - RT_OFFSETOF(VUSBCTRLEXTRA, Urb));
1320 if ( pUrb->enmState == VUSBURBSTATE_CANCELLED
1321 && !pUrb->VUsb.pvFreeCtx)
1322 {
1323 LogFlow(("vusbMsgFreeUrb: Freeing orphan: %p (pUrb=%p)\n", pExtra, pUrb));
1324 RTMemFree(pExtra);
1325 }
1326 else
1327 {
1328 Assert(pUrb->VUsb.pvFreeCtx == &pExtra->Urb);
1329 pUrb->enmState = VUSBURBSTATE_ALLOCATED;
1330 }
1331}
1332
1333/**
1334 * Frees the extra state data associated with a message pipe.
1335 *
1336 * @param pExtra The data.
1337 */
1338void vusbMsgFreeExtraData(PVUSBCTRLEXTRA pExtra)
1339{
1340 if (!pExtra)
1341 return;
1342 if (pExtra->Urb.enmState != VUSBURBSTATE_CANCELLED)
1343 {
1344 pExtra->Urb.u32Magic = 0;
1345 pExtra->Urb.enmState = VUSBURBSTATE_FREE;
1346 if (pExtra->Urb.pszDesc)
1347 RTStrFree(pExtra->Urb.pszDesc);
1348 RTMemFree(pExtra);
1349 }
1350 else
1351 pExtra->Urb.VUsb.pvFreeCtx = NULL; /* see vusbMsgFreeUrb */
1352}
1353
1354/**
1355 * Allocates the extra state data required for a control pipe.
1356 *
1357 * @returns Pointer to the allocated and initialized state data.
1358 * @returns NULL on out of memory condition.
1359 * @param pUrb A URB we can copy default data from.
1360 */
1361static PVUSBCTRLEXTRA vusbMsgAllocExtraData(PVUSBURB pUrb)
1362{
1363/** @todo reuse these? */
1364 PVUSBCTRLEXTRA pExtra;
1365 const size_t cbMax = sizeof(pExtra->Urb.abData) + sizeof(VUSBSETUP);
1366 pExtra = (PVUSBCTRLEXTRA)RTMemAllocZ(RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbMax]));
1367 if (pExtra)
1368 {
1369 pExtra->enmStage = CTLSTAGE_SETUP;
1370 //pExtra->fOk = false;
1371 pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
1372 pExtra->pbCur = (uint8_t *)(pExtra->pMsg + 1);
1373 //pExtra->cbLeft = 0;
1374 pExtra->cbMax = cbMax;
1375
1376 //pExtra->Urb.Dev.pvProxyUrb = NULL;
1377 pExtra->Urb.u32Magic = VUSBURB_MAGIC;
1378 pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
1379#ifdef LOG_ENABLED
1380 RTStrAPrintf(&pExtra->Urb.pszDesc, "URB %p msg->%p", &pExtra->Urb, pUrb);
1381#endif
1382 //pExtra->Urb.VUsb.pCtrlUrb = NULL;
1383 //pExtra->Urb.VUsb.pNext = NULL;
1384 //pExtra->Urb.VUsb.ppPrev = NULL;
1385 pExtra->Urb.VUsb.pDev = pUrb->VUsb.pDev;
1386 pExtra->Urb.VUsb.pfnFree = vusbMsgFreeUrb;
1387 pExtra->Urb.VUsb.pvFreeCtx = &pExtra->Urb;
1388 //pExtra->Urb.Hci = {0};
1389 //pExtra->Urb.Dev.pvProxyUrb = NULL;
1390 pExtra->Urb.pUsbIns = pUrb->pUsbIns;
1391 pExtra->Urb.DstAddress = pUrb->DstAddress;
1392 pExtra->Urb.EndPt = pUrb->EndPt;
1393 pExtra->Urb.enmType = VUSBXFERTYPE_MSG;
1394 pExtra->Urb.enmDir = VUSBDIRECTION_INVALID;
1395 //pExtra->Urb.fShortNotOk = false;
1396 pExtra->Urb.enmStatus = VUSBSTATUS_INVALID;
1397 //pExtra->Urb.cbData = 0;
1398 vusbUrbAssert(&pExtra->Urb);
1399 }
1400 return pExtra;
1401}
1402
1403/**
1404 * Sets up the message.
1405 *
1406 * The message is associated with the pipe, in what's currently called
1407 * control pipe extra state data (pointed to by pPipe->pCtrl). If this
1408 * is a OUT message, we will no go on collecting data URB. If it's a
1409 * IN message, we'll send it and then queue any incoming data for the
1410 * URBs collecting it.
1411 *
1412 * @returns Success indicator.
1413 */
1414static bool vusbMsgSetup(PVUSBPIPE pPipe, const void *pvBuf, uint32_t cbBuf)
1415{
1416 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
1417 const VUSBSETUP *pSetupIn = (PVUSBSETUP)pvBuf;
1418
1419 /*
1420 * Validate length.
1421 */
1422 if (cbBuf < sizeof(VUSBSETUP))
1423 {
1424 LogFlow(("vusbMsgSetup: pPipe=%p cbBuf=%u < %u (failure) !!!\n",
1425 pPipe, cbBuf, sizeof(VUSBSETUP)));
1426 return false;
1427 }
1428
1429 /*
1430 * Check if we've got an cancelled message URB. Allocate a new one in that case.
1431 */
1432 if (pExtra->Urb.enmState == VUSBURBSTATE_CANCELLED)
1433 {
1434 void *pvNew = RTMemDup(pExtra, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax]));
1435 if (!pvNew)
1436 {
1437 Log(("vusbMsgSetup: out of memory!!! cbReq=%u\n", RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[pExtra->cbMax])));
1438 return false;
1439 }
1440 pExtra->Urb.VUsb.pvFreeCtx = NULL;
1441 LogFlow(("vusbMsgSetup: Replacing canceled pExtra=%p with %p.\n", pExtra, pvNew));
1442 pPipe->pCtrl = pExtra = (PVUSBCTRLEXTRA)pvNew;
1443 pExtra->pMsg = (PVUSBSETUP)pExtra->Urb.abData;
1444 pExtra->Urb.enmState = VUSBURBSTATE_ALLOCATED;
1445 }
1446
1447 /*
1448 * Check that we've got sufficient space in the message URB.
1449 */
1450 if (pExtra->cbMax < cbBuf + pSetupIn->wLength)
1451 {
1452 uint32_t cbReq = RT_ALIGN_32(cbBuf + pSetupIn->wLength, 1024);
1453 PVUSBCTRLEXTRA pNew = (PVUSBCTRLEXTRA)RTMemRealloc(pExtra, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbReq]));
1454 if (!pNew)
1455 {
1456 Log(("vusbMsgSetup: out of memory!!! cbReq=%u %u\n",
1457 cbReq, RT_OFFSETOF(VUSBCTRLEXTRA, Urb.abData[cbReq])));
1458 return false;
1459 }
1460 if (pExtra != pNew)
1461 {
1462 pNew->pMsg = (PVUSBSETUP)pNew->Urb.abData;
1463 pExtra = pNew;
1464 }
1465 pExtra->cbMax = cbReq;
1466 }
1467 Assert(pExtra->Urb.enmState == VUSBURBSTATE_ALLOCATED);
1468
1469 /*
1470 * Copy the setup data and prepare for data.
1471 */
1472 PVUSBSETUP pSetup = pExtra->pMsg;
1473 pExtra->fSubmitted = false;
1474 pExtra->Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
1475 pExtra->pbCur = (uint8_t *)(pSetup + 1);
1476 pSetup->bmRequestType = pSetupIn->bmRequestType;
1477 pSetup->bRequest = pSetupIn->bRequest;
1478 pSetup->wValue = RT_LE2H_U16(pSetupIn->wValue);
1479 pSetup->wIndex = RT_LE2H_U16(pSetupIn->wIndex);
1480 pSetup->wLength = RT_LE2H_U16(pSetupIn->wLength);
1481
1482 LogFlow(("vusbMsgSetup(%p,,%d): bmRequestType=%#04x bRequest=%#04x wValue=%#06x wIndex=%#06x wLength=0x%.4x\n",
1483 pPipe, cbBuf, pSetup->bmRequestType, pSetup->bRequest, pSetup->wValue, pSetup->wIndex, pSetup->wLength));
1484 return true;
1485}
1486
1487/**
1488 * Build the message URB from the given control URB and accompanying message
1489 * pipe state which we grab from the device for the URB.
1490 *
1491 * @param pUrb The URB to submit.
1492 */
1493static void vusbMsgDoTransfer(PVUSBURB pUrb, PVUSBSETUP pSetup, PVUSBCTRLEXTRA pExtra, PVUSBPIPE pPipe, PVUSBDEV pDev)
1494{
1495 /*
1496 * Mark this transfer as sent (cleared at setup time).
1497 */
1498 Assert(!pExtra->fSubmitted);
1499 pExtra->fSubmitted = true;
1500
1501 /*
1502 * Do we have to do this synchronously?
1503 */
1504 bool fSafeRequest = vusbUrbIsRequestSafe(pSetup, pUrb);
1505 if (!fSafeRequest)
1506 {
1507 vusbMsgSubmitSynchronously(pUrb, fSafeRequest);
1508 return;
1509 }
1510
1511 /*
1512 * Do it asynchronously.
1513 */
1514 LogFlow(("%s: vusbMsgDoTransfer: ep=%d pMsgUrb=%p pPipe=%p stage=%s\n",
1515 pUrb->pszDesc, pUrb->EndPt, &pExtra->Urb, pPipe, g_apszCtlStates[pExtra->enmStage]));
1516 Assert(pExtra->Urb.enmType == VUSBXFERTYPE_MSG);
1517 Assert(pExtra->Urb.EndPt == pUrb->EndPt);
1518 pExtra->Urb.enmDir = (pSetup->bmRequestType & VUSB_DIR_TO_HOST) ? VUSBDIRECTION_IN : VUSBDIRECTION_OUT;
1519 pExtra->Urb.cbData = pSetup->wLength + sizeof(*pSetup);
1520 pExtra->Urb.VUsb.pCtrlUrb = pUrb;
1521 int rc = vusbUrbQueueAsyncRh(&pExtra->Urb);
1522 if (RT_FAILURE(rc))
1523 {
1524 /*
1525 * If we fail submitting it, will not retry but fail immediately.
1526 *
1527 * This keeps things simple. The host OS will have retried if
1528 * it's a proxied device, and if it's a virtual one it really means
1529 * it if it's failing a control message.
1530 */
1531 LogFlow(("%s: vusbMsgDoTransfer: failed submitting urb! failing it with %s (rc=%Rrc)!!!\n",
1532 pUrb->pszDesc, rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? "DNR" : "CRC", rc));
1533 pExtra->Urb.enmStatus = rc == VERR_VUSB_DEVICE_NOT_ATTACHED ? VUSBSTATUS_DNR : VUSBSTATUS_CRC;
1534 pExtra->Urb.enmState = VUSBURBSTATE_REAPED;
1535 vusbMsgCompletion(&pExtra->Urb);
1536 }
1537}
1538
1539/**
1540 * Fails a URB request with a pipe STALL error.
1541 *
1542 * @returns VINF_SUCCESS indicating that we've completed the URB.
1543 * @param pUrb The URB in question.
1544 */
1545static int vusbMsgStall(PVUSBURB pUrb)
1546{
1547 PVUSBPIPE pPipe = &pUrb->VUsb.pDev->aPipes[pUrb->EndPt];
1548 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
1549 LogFlow(("%s: vusbMsgStall: pPipe=%p err=STALL stage %s->SETUP\n",
1550 pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
1551
1552 pExtra->pbCur = NULL;
1553 pExtra->enmStage = CTLSTAGE_SETUP;
1554 pUrb->enmState = VUSBURBSTATE_REAPED;
1555 pUrb->enmStatus = VUSBSTATUS_STALL;
1556 vusbUrbCompletionRh(pUrb);
1557 return VINF_SUCCESS;
1558}
1559
1560/**
1561 * Submit a control message.
1562 *
1563 * Here we implement the USB defined traffic that occurs in message pipes
1564 * (aka control endpoints). We want to provide a single function for device
1565 * drivers so that they don't all have to reimplement the usb logic for
1566 * themselves. This means we need to keep a little bit of state information
1567 * because control transfers occur over multiple bus transactions. We may
1568 * also need to buffer data over multiple data stages.
1569 *
1570 * @returns VBox status code.
1571 * @param pUrb The URB to submit.
1572 */
1573static int vusbUrbSubmitCtrl(PVUSBURB pUrb)
1574{
1575#ifdef LOG_ENABLED
1576 vusbUrbTrace(pUrb, "vusbUrbSubmitCtrl", false);
1577#endif
1578 PVUSBDEV pDev = pUrb->VUsb.pDev;
1579 PVUSBPIPE pPipe = &pDev->aPipes[pUrb->EndPt];
1580
1581 RTCritSectEnter(&pPipe->CritSectCtrl);
1582 PVUSBCTRLEXTRA pExtra = pPipe->pCtrl;
1583
1584 if (!pExtra && !(pExtra = pPipe->pCtrl = vusbMsgAllocExtraData(pUrb)))
1585 {
1586 RTCritSectLeave(&pPipe->CritSectCtrl);
1587 return VERR_VUSB_NO_URB_MEMORY;
1588 }
1589 PVUSBSETUP pSetup = pExtra->pMsg;
1590
1591 AssertMsgReturn(!pPipe->async, ("%u\n", pPipe->async), VERR_GENERAL_FAILURE);
1592
1593
1594 /*
1595 * A setup packet always resets the transaction and the
1596 * end of data transmission is signified by change in
1597 * data direction.
1598 */
1599 if (pUrb->enmDir == VUSBDIRECTION_SETUP)
1600 {
1601 LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->SETUP\n",
1602 pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
1603 pExtra->enmStage = CTLSTAGE_SETUP;
1604 }
1605 else if ( pExtra->enmStage == CTLSTAGE_DATA
1606 /* (the STATUS stage direction goes the other way) */
1607 && !!(pSetup->bmRequestType & VUSB_DIR_TO_HOST) != (pUrb->enmDir == VUSBDIRECTION_IN))
1608 {
1609 LogFlow(("%s: vusbUrbSubmitCtrl: pPipe=%p state %s->STATUS\n",
1610 pUrb->pszDesc, pPipe, g_apszCtlStates[pExtra->enmStage]));
1611 pExtra->enmStage = CTLSTAGE_STATUS;
1612 }
1613
1614 /*
1615 * Act according to the current message stage.
1616 */
1617 switch (pExtra->enmStage)
1618 {
1619 case CTLSTAGE_SETUP:
1620 /*
1621 * When stall handshake is returned, all subsequent packets
1622 * must generate stall until a setup packet arrives.
1623 */
1624 if (pUrb->enmDir != VUSBDIRECTION_SETUP)
1625 {
1626 Log(("%s: vusbUrbSubmitCtrl: Stall at setup stage (dir=%#x)!!\n", pUrb->pszDesc, pUrb->enmDir));
1627 vusbMsgStall(pUrb);
1628 break;
1629 }
1630
1631 /* Store setup details, return DNR if corrupt */
1632 if (!vusbMsgSetup(pPipe, pUrb->abData, pUrb->cbData))
1633 {
1634 pUrb->enmState = VUSBURBSTATE_REAPED;
1635 pUrb->enmStatus = VUSBSTATUS_DNR;
1636 vusbUrbCompletionRh(pUrb);
1637 break;
1638 }
1639 if (pPipe->pCtrl != pExtra)
1640 {
1641 pExtra = pPipe->pCtrl;
1642 pSetup = pExtra->pMsg;
1643 }
1644
1645 /* pre-buffer our output if it's device-to-host */
1646 if (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
1647 vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
1648 else if (pSetup->wLength)
1649 {
1650 LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: need data\n", pUrb->pszDesc));
1651 pUrb->enmState = VUSBURBSTATE_REAPED;
1652 vusbMsgSetupCompletion(pUrb);
1653 vusbUrbCompletionRh(pUrb);
1654 }
1655 /*
1656 * If there is no DATA stage, we must send it now since there are
1657 * no requirement of a STATUS stage.
1658 */
1659 else
1660 {
1661 LogFlow(("%s: vusbUrbSubmitCtrl: stage=SETUP - to dev: sending\n", pUrb->pszDesc));
1662 vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
1663 }
1664 break;
1665
1666 case CTLSTAGE_DATA:
1667 {
1668 /*
1669 * If a data stage exceeds the target buffer indicated in
1670 * setup return stall, if data stage returns stall there
1671 * will be no status stage.
1672 */
1673 uint8_t *pbData = (uint8_t *)(pExtra->pMsg + 1);
1674 if (&pExtra->pbCur[pUrb->cbData] > &pbData[pSetup->wLength])
1675 {
1676 if (!pSetup->wLength) /* happens during iPhone detection with iTunes (correct?) */
1677 {
1678 Log(("%s: vusbUrbSubmitCtrl: pSetup->wLength == 0!! (iPhone)\n", pUrb->pszDesc));
1679 pSetup->wLength = pUrb->cbData;
1680 }
1681
1682 /* Variable length data transfers */
1683 if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
1684 || pSetup->wLength == 0
1685 || (pUrb->cbData % pSetup->wLength) == 0) /* magic which need explaining... */
1686 {
1687 uint8_t *pbEnd = pbData + pSetup->wLength;
1688 int cbLeft = pbEnd - pExtra->pbCur;
1689 LogFlow(("%s: vusbUrbSubmitCtrl: Var DATA, pUrb->cbData %d -> %d\n", pUrb->pszDesc, pUrb->cbData, cbLeft));
1690 pUrb->cbData = cbLeft;
1691 }
1692 else
1693 {
1694 Log(("%s: vusbUrbSubmitCtrl: Stall at data stage!!\n", pUrb->pszDesc));
1695 vusbMsgStall(pUrb);
1696 break;
1697 }
1698 }
1699
1700 if (pUrb->enmDir == VUSBDIRECTION_IN)
1701 {
1702 /* put data received from the device. */
1703 const uint32_t cbRead = RT_MIN(pUrb->cbData, pExtra->cbLeft);
1704 memcpy(pUrb->abData, pExtra->pbCur, cbRead);
1705
1706 /* advance */
1707 pExtra->pbCur += cbRead;
1708 if (pUrb->cbData == cbRead)
1709 pExtra->cbLeft -= pUrb->cbData;
1710 else
1711 {
1712 /* adjust the pUrb->cbData to reflect the number of bytes containing actual data. */
1713 LogFlow(("%s: vusbUrbSubmitCtrl: adjusting last DATA pUrb->cbData, %d -> %d\n",
1714 pUrb->pszDesc, pUrb->cbData, pExtra->cbLeft));
1715 pUrb->cbData = cbRead;
1716 pExtra->cbLeft = 0;
1717 }
1718 }
1719 else
1720 {
1721 /* get data for sending when completed. */
1722 memcpy(pExtra->pbCur, pUrb->abData, pUrb->cbData);
1723
1724 /* advance */
1725 pExtra->pbCur += pUrb->cbData;
1726
1727 /*
1728 * If we've got the necessary data, we'll send it now since there are
1729 * no requirement of a STATUS stage.
1730 */
1731 if ( !pExtra->fSubmitted
1732 && pExtra->pbCur - pbData >= pSetup->wLength)
1733 {
1734 LogFlow(("%s: vusbUrbSubmitCtrl: stage=DATA - to dev: sending\n", pUrb->pszDesc));
1735 vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
1736 break;
1737 }
1738 }
1739
1740 pUrb->enmState = VUSBURBSTATE_REAPED;
1741 vusbMsgDataCompletion(pUrb);
1742 vusbUrbCompletionRh(pUrb);
1743 break;
1744 }
1745
1746 case CTLSTAGE_STATUS:
1747 if ( (pSetup->bmRequestType & VUSB_DIR_TO_HOST)
1748 || pExtra->fSubmitted)
1749 {
1750 Assert(pExtra->fSubmitted);
1751 pUrb->enmState = VUSBURBSTATE_REAPED;
1752 vusbMsgStatusCompletion(pUrb);
1753 vusbUrbCompletionRh(pUrb);
1754 }
1755 else
1756 {
1757 LogFlow(("%s: vusbUrbSubmitCtrl: stage=STATUS - to dev: sending\n", pUrb->pszDesc));
1758 vusbMsgDoTransfer(pUrb, pSetup, pExtra, pPipe, pDev);
1759 }
1760 break;
1761 }
1762
1763 RTCritSectLeave(&pPipe->CritSectCtrl);
1764 return VINF_SUCCESS;
1765}
1766
1767
1768/**
1769 * Submit a interrupt URB.
1770 *
1771 * @returns VBox status code.
1772 * @param pUrb The URB to submit.
1773 */
1774static int vusbUrbSubmitInterrupt(PVUSBURB pUrb)
1775{
1776 LogFlow(("%s: vusbUrbSubmitInterrupt: (sync)\n", pUrb->pszDesc));
1777 return vusbUrbQueueAsyncRh(pUrb);
1778}
1779
1780
1781/**
1782 * Submit a bulk URB.
1783 *
1784 * @returns VBox status code.
1785 * @param pUrb The URB to submit.
1786 */
1787static int vusbUrbSubmitBulk(PVUSBURB pUrb)
1788{
1789 LogFlow(("%s: vusbUrbSubmitBulk: (async)\n", pUrb->pszDesc));
1790 return vusbUrbQueueAsyncRh(pUrb);
1791}
1792
1793
1794/**
1795 * Submit an isochronous URB.
1796 *
1797 * @returns VBox status code.
1798 * @param pUrb The URB to submit.
1799 */
1800static int vusbUrbSubmitIsochronous(PVUSBURB pUrb)
1801{
1802 LogFlow(("%s: vusbUrbSubmitIsochronous: (async)\n", pUrb->pszDesc));
1803 return vusbUrbQueueAsyncRh(pUrb);
1804}
1805
1806
1807/**
1808 * Fail a URB with a 'hard-error' sort of error.
1809 *
1810 * @return VINF_SUCCESS (the Urb status indicates the error).
1811 * @param pUrb The URB.
1812 */
1813int vusbUrbSubmitHardError(PVUSBURB pUrb)
1814{
1815 /* FIXME: Find out the correct return code from the spec */
1816 pUrb->enmState = VUSBURBSTATE_REAPED;
1817 pUrb->enmStatus = VUSBSTATUS_DNR;
1818 vusbUrbCompletionRh(pUrb);
1819 return VINF_SUCCESS;
1820}
1821
1822
1823/**
1824 * Submit a URB.
1825 */
1826int vusbUrbSubmit(PVUSBURB pUrb)
1827{
1828 vusbUrbAssert(pUrb);
1829 Assert(pUrb->enmState == VUSBURBSTATE_ALLOCATED);
1830 PVUSBDEV pDev = pUrb->VUsb.pDev;
1831 PVUSBPIPE pPipe = NULL;
1832 Assert(pDev);
1833
1834 /*
1835 * Check that the device is in a valid state.
1836 */
1837 const VUSBDEVICESTATE enmState = vusbDevGetState(pDev);
1838 if (enmState == VUSB_DEVICE_STATE_RESET)
1839 {
1840 LogRel(("VUSB: %s: power off ignored, the device is resetting!\n", pDev->pUsbIns->pszName));
1841 pUrb->enmStatus = VUSBSTATUS_DNR;
1842 /* This will postpone the TDs until we're done with the resetting. */
1843 return VERR_VUSB_DEVICE_IS_RESETTING;
1844 }
1845
1846#ifdef LOG_ENABLED
1847 /* stamp it */
1848 pUrb->VUsb.u64SubmitTS = RTTimeNanoTS();
1849#endif
1850
1851 /** @todo Check max packet size here too? */
1852
1853 /*
1854 * Validate the pipe.
1855 */
1856 if (pUrb->EndPt >= VUSB_PIPE_MAX)
1857 {
1858 Log(("%s: pDev=%p[%s]: SUBMIT: ep %i >= %i!!!\n", pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, pUrb->EndPt, VUSB_PIPE_MAX));
1859 return vusbUrbSubmitHardError(pUrb);
1860 }
1861 PCVUSBDESCENDPOINTEX pEndPtDesc;
1862 switch (pUrb->enmDir)
1863 {
1864 case VUSBDIRECTION_IN:
1865 pEndPtDesc = pDev->aPipes[pUrb->EndPt].in;
1866 pPipe = &pDev->aPipes[pUrb->EndPt];
1867 break;
1868 case VUSBDIRECTION_SETUP:
1869 case VUSBDIRECTION_OUT:
1870 default:
1871 pEndPtDesc = pDev->aPipes[pUrb->EndPt].out;
1872 break;
1873 }
1874 if (!pEndPtDesc)
1875 {
1876 Log(("%s: pDev=%p[%s]: SUBMIT: no endpoint!!! dir=%s e=%i\n",
1877 pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbDirName(pUrb->enmDir), pUrb->EndPt));
1878 return vusbUrbSubmitHardError(pUrb);
1879 }
1880
1881 /*
1882 * Check for correct transfer types.
1883 * Our type codes are the same - what a coincidence.
1884 */
1885 if ((pEndPtDesc->Core.bmAttributes & 0x3) != pUrb->enmType)
1886 {
1887 Log(("%s: pDev=%p[%s]: SUBMIT: %s transfer requested for %#x endpoint on DstAddress=%i ep=%i dir=%s\n",
1888 pUrb->pszDesc, pDev, pDev->pUsbIns->pszName, vusbUrbTypeName(pUrb->enmType), pEndPtDesc->Core.bmAttributes,
1889 pUrb->DstAddress, pUrb->EndPt, vusbUrbDirName(pUrb->enmDir)));
1890 return vusbUrbSubmitHardError(pUrb);
1891 }
1892
1893 /*
1894 * If there's a URB in the read-ahead buffer, use it.
1895 */
1896 int rc;
1897
1898#ifdef VBOX_WITH_USB
1899 if (pPipe && pPipe->hReadAhead)
1900 {
1901 rc = vusbUrbSubmitBufferedRead(pUrb, pPipe->hReadAhead);
1902 return rc;
1903 }
1904#endif
1905
1906 /*
1907 * Take action based on type.
1908 */
1909 pUrb->enmState = VUSBURBSTATE_IN_FLIGHT;
1910 switch (pUrb->enmType)
1911 {
1912 case VUSBXFERTYPE_CTRL:
1913 rc = vusbUrbSubmitCtrl(pUrb);
1914 break;
1915 case VUSBXFERTYPE_BULK:
1916 rc = vusbUrbSubmitBulk(pUrb);
1917 break;
1918 case VUSBXFERTYPE_INTR:
1919 rc = vusbUrbSubmitInterrupt(pUrb);
1920 break;
1921 case VUSBXFERTYPE_ISOC:
1922 rc = vusbUrbSubmitIsochronous(pUrb);
1923 break;
1924 default:
1925 AssertMsgFailed(("Unexpected pUrb type %d\n", pUrb->enmType));
1926 return vusbUrbSubmitHardError(pUrb);
1927 }
1928
1929 /*
1930 * The device was detached, so we fail everything.
1931 * (We should really detach and destroy the device, but we'll have to wait till Main reacts.)
1932 */
1933 if (rc == VERR_VUSB_DEVICE_NOT_ATTACHED)
1934 rc = vusbUrbSubmitHardError(pUrb);
1935 /*
1936 * We don't increment error count if async URBs are in flight, in
1937 * this case we just assume we need to throttle back, this also
1938 * makes sure we don't halt bulk endpoints at the wrong time.
1939 */
1940 else if ( RT_FAILURE(rc)
1941 && !ASMAtomicReadU32(&pDev->aPipes[pUrb->EndPt].async)
1942 /* && pUrb->enmType == VUSBXFERTYPE_BULK ?? */
1943 && !vusbUrbErrorRh(pUrb))
1944 {
1945 /* don't retry it anymore. */
1946 pUrb->enmState = VUSBURBSTATE_REAPED;
1947 pUrb->enmStatus = VUSBSTATUS_CRC;
1948 vusbUrbCompletionRh(pUrb);
1949 return VINF_SUCCESS;
1950 }
1951
1952 return rc;
1953}
1954
1955
1956/**
1957 * Reap in-flight URBs.
1958 *
1959 * @param pHead Pointer to the head of the URB list.
1960 * @param cMillies Number of milliseconds to block in each reap operation.
1961 * Use 0 to not block at all.
1962 */
1963void vusbUrbDoReapAsync(PVUSBURB pHead, RTMSINTERVAL cMillies)
1964{
1965 PVUSBURB pUrb = pHead;
1966 while (pUrb)
1967 {
1968 vusbUrbAssert(pUrb);
1969 PVUSBURB pUrbNext = pUrb->VUsb.pNext;
1970 PVUSBDEV pDev = pUrb->VUsb.pDev;
1971
1972 /* Don't touch resetting devices - paranoid safety precaution. */
1973 if (vusbDevGetState(pDev) != VUSB_DEVICE_STATE_RESET)
1974 {
1975 /*
1976 * Reap most URBs pending on a single device.
1977 */
1978 PVUSBURB pRipe;
1979
1980 /**
1981 * This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
1982 * and leaked URBs (shouldn't be affected by leaked URBs).
1983 */
1984 Assert(pDev->pUsbIns);
1985 while ( pDev->pUsbIns
1986 && ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
1987 {
1988 vusbUrbAssert(pRipe);
1989 if (pRipe == pUrbNext)
1990 pUrbNext = pUrbNext->VUsb.pNext;
1991 vusbUrbRipe(pRipe);
1992 }
1993 }
1994
1995 /* next */
1996 pUrb = pUrbNext;
1997 }
1998}
1999
2000/**
2001 * Reap URBs on a per device level.
2002 *
2003 * @returns nothing.
2004 * @param pDev The device instance to reap URBs for.
2005 * @param cMillies Number of milliseconds to block in each reap operation.
2006 * Use 0 to not block at all.
2007 */
2008void vusbUrbDoReapAsyncDev(PVUSBDEV pDev, RTMSINTERVAL cMillies)
2009{
2010 Assert(pDev->enmState != VUSB_DEVICE_STATE_RESET);
2011
2012 /*
2013 * Reap most URBs pending on a single device.
2014 */
2015 PVUSBURB pRipe;
2016
2017 /**
2018 * This is workaround for race(should be fixed) detach on one EMT thread and frame boundary timer on other
2019 * and leaked URBs (shouldn't be affected by leaked URBs).
2020 */
2021
2022 if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
2023 return;
2024
2025 Assert(pDev->pUsbIns);
2026 while ( pDev->pUsbIns
2027 && ((pRipe = pDev->pUsbIns->pReg->pfnUrbReap(pDev->pUsbIns, cMillies)) != NULL))
2028 {
2029 vusbUrbAssert(pRipe);
2030 vusbUrbRipe(pRipe);
2031 if (ASMAtomicXchgBool(&pDev->fWokenUp, false))
2032 break;
2033 }
2034}
2035
2036/**
2037 * Completes the URB.
2038 */
2039static void vusbUrbCompletion(PVUSBURB pUrb)
2040{
2041 Assert(pUrb->VUsb.pDev->aPipes);
2042 ASMAtomicDecU32(&pUrb->VUsb.pDev->aPipes[pUrb->EndPt].async);
2043
2044 if (pUrb->enmState == VUSBURBSTATE_REAPED)
2045 vusbUrbUnlink(pUrb);
2046#ifdef VBOX_WITH_USB
2047 // Read-ahead URBs are handled differently
2048 if (pUrb->Hci.pNext != NULL)
2049 vusbUrbCompletionReadAhead(pUrb);
2050 else
2051#endif
2052 vusbUrbCompletionRh(pUrb);
2053}
2054
2055/**
2056 * The worker for vusbUrbCancel() which is executed on the I/O thread.
2057 *
2058 * @returns nothing.
2059 * @param pUrb The URB to cancel.
2060 * @param enmMode The way the URB should be canceled.
2061 */
2062DECLHIDDEN(void) vusbUrbCancelWorker(PVUSBURB pUrb, CANCELMODE enmMode)
2063{
2064 vusbUrbAssert(pUrb);
2065#ifdef VBOX_WITH_STATISTICS
2066 PVUSBROOTHUB pRh = vusbDevGetRh(pUrb->VUsb.pDev);
2067#endif
2068 if (pUrb->enmState == VUSBURBSTATE_IN_FLIGHT)
2069 {
2070 LogFlow(("%s: vusbUrbCancel: Canceling in-flight\n", pUrb->pszDesc));
2071 STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
2072 if (pUrb->enmType != VUSBXFERTYPE_MSG)
2073 {
2074 STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
2075 STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
2076 }
2077
2078 pUrb->enmState = VUSBURBSTATE_CANCELLED;
2079 PPDMUSBINS pUsbIns = pUrb->pUsbIns;
2080 pUsbIns->pReg->pfnUrbCancel(pUsbIns, pUrb);
2081 Assert(pUrb->enmState == VUSBURBSTATE_CANCELLED || pUrb->enmState == VUSBURBSTATE_REAPED);
2082
2083 pUrb->enmStatus = VUSBSTATUS_CRC;
2084 vusbUrbCompletion(pUrb);
2085 }
2086 else if (pUrb->enmState == VUSBURBSTATE_REAPED)
2087 {
2088 LogFlow(("%s: vusbUrbCancel: Canceling reaped urb\n", pUrb->pszDesc));
2089 STAM_COUNTER_INC(&pRh->Total.StatUrbsCancelled);
2090 if (pUrb->enmType != VUSBXFERTYPE_MSG)
2091 {
2092 STAM_STATS({Assert(pUrb->enmType >= 0 && pUrb->enmType < (int)RT_ELEMENTS(pRh->aTypes));});
2093 STAM_COUNTER_INC(&pRh->aTypes[pUrb->enmType].StatUrbsCancelled);
2094 }
2095
2096 pUrb->enmStatus = VUSBSTATUS_CRC;
2097 vusbUrbCompletion(pUrb);
2098 }
2099 else
2100 {
2101 AssertMsg(pUrb->enmState == VUSBURBSTATE_CANCELLED, ("Invalid state %d, pUrb=%p\n", pUrb->enmState, pUrb));
2102 switch (enmMode)
2103 {
2104 default:
2105 AssertMsgFailed(("Invalid cancel mode\n"));
2106 case CANCELMODE_FAIL:
2107 pUrb->enmStatus = VUSBSTATUS_CRC;
2108 break;
2109 case CANCELMODE_UNDO:
2110 pUrb->enmStatus = VUSBSTATUS_UNDO;
2111 break;
2112
2113 }
2114 }
2115}
2116
2117/**
2118 * Cancels an URB with CRC failure.
2119 *
2120 * Cancelling an URB is a tricky thing. The USBProxy backend can not
2121 * all cancel it and we must keep the URB around until it's ripe and
2122 * can be reaped the normal way. However, we must complete the URB
2123 * now, before leaving this function. This is not nice. sigh.
2124 *
2125 * This function will cancel the URB if it's in-flight and complete
2126 * it. The device will in its pfnCancel method be given the chance to
2127 * say that the URB doesn't need reaping and should be unlinked.
2128 *
2129 * An URB which is in the cancel state after pfnCancel will remain in that
2130 * state and in the async list until its reaped. When it's finally reaped
2131 * it will be unlinked and freed without doing any completion.
2132 *
2133 * There are different modes of canceling an URB. When devices are being
2134 * disconnected etc., they will be completed with an error (CRC). However,
2135 * when the HC needs to temporarily halt communication with a device, the
2136 * URB/TD must be left alone if possible.
2137 *
2138 * @param pUrb The URB to cancel.
2139 * @param mode The way the URB should be canceled.
2140 */
2141void vusbUrbCancel(PVUSBURB pUrb, CANCELMODE mode)
2142{
2143 int rc = vusbDevIoThreadExecSync(pUrb->VUsb.pDev, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
2144 AssertRC(rc);
2145}
2146
2147
2148/**
2149 * Async version of vusbUrbCancel() - doesn't wait for the cancelling to be complete.
2150 */
2151void vusbUrbCancelAsync(PVUSBURB pUrb, CANCELMODE mode)
2152{
2153 int rc = vusbDevIoThreadExec(pUrb->VUsb.pDev, 0 /* fFlags */, (PFNRT)vusbUrbCancelWorker, 2, pUrb, mode);
2154 AssertRC(rc);
2155}
2156
2157
2158/**
2159 * Deals with a ripe URB (i.e. after reaping it).
2160 *
2161 * If an URB is in the reaped or in-flight state, we'll
2162 * complete it. If it's cancelled, we'll simply free it.
2163 * Any other states should never get here.
2164 *
2165 * @param pUrb The URB.
2166 */
2167void vusbUrbRipe(PVUSBURB pUrb)
2168{
2169 if ( pUrb->enmState == VUSBURBSTATE_IN_FLIGHT
2170 || pUrb->enmState == VUSBURBSTATE_REAPED)
2171 {
2172 pUrb->enmState = VUSBURBSTATE_REAPED;
2173 vusbUrbCompletion(pUrb);
2174 }
2175 else if (pUrb->enmState == VUSBURBSTATE_CANCELLED)
2176 {
2177 vusbUrbUnlink(pUrb);
2178 LogFlow(("%s: vusbUrbRipe: Freeing cancelled URB\n", pUrb->pszDesc));
2179 pUrb->VUsb.pfnFree(pUrb);
2180 }
2181 else
2182 AssertMsgFailed(("Invalid URB state %d; %s\n", pUrb->enmState, pUrb->pszDesc));
2183}
2184
2185
2186/*
2187 * Local Variables:
2188 * mode: c
2189 * c-file-style: "bsd"
2190 * c-basic-offset: 4
2191 * tab-width: 4
2192 * indent-tabs-mode: s
2193 * End:
2194 */
2195
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette