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. */
|
---|
42 | const char * const g_apszCtlStates[4] =
|
---|
43 | {
|
---|
44 | "SETUP",
|
---|
45 | "DATA",
|
---|
46 | "STATUS",
|
---|
47 | "N/A"
|
---|
48 | };
|
---|
49 |
|
---|
50 |
|
---|
51 | /*******************************************************************************
|
---|
52 | * Internal Functions *
|
---|
53 | *******************************************************************************/
|
---|
54 | static PVUSBCTRLEXTRA vusbMsgAllocExtraData(PVUSBURB pUrb);
|
---|
55 |
|
---|
56 |
|
---|
57 | #ifdef LOG_ENABLED
|
---|
58 | DECLINLINE(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 |
|
---|
80 | DECLINLINE(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 |
|
---|
95 | DECLINLINE(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 |
|
---|
112 | DECLINLINE(const char *) GetScsiErrCd(uint8_t ScsiErr)
|
---|
113 | {
|
---|
114 | switch (ScsiErr)
|
---|
115 | {
|
---|
116 | case 0: return "?";
|
---|
117 | }
|
---|
118 | return "?";
|
---|
119 | }
|
---|
120 |
|
---|
121 | DECLINLINE(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 | */
|
---|
165 | void 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 | */
|
---|
839 | static 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 | */
|
---|
858 | static 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 | */
|
---|
877 | static 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 | */
|
---|
918 | static 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 | */
|
---|
945 | static 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 | */
|
---|
993 | int 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 | */
|
---|
1007 | void 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 | */
|
---|
1141 | DECLINLINE(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 | */
|
---|
1192 | int 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 | */
|
---|
1235 | static 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 | */
|
---|
1278 | void 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 | */
|
---|
1316 | static 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 | */
|
---|
1338 | void 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 | */
|
---|
1361 | static 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 | */
|
---|
1414 | static 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 | */
|
---|
1493 | static 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 | */
|
---|
1545 | static 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 | */
|
---|
1573 | static 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 | */
|
---|
1774 | static 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 | */
|
---|
1787 | static 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 | */
|
---|
1800 | static 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 | */
|
---|
1813 | int 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 | */
|
---|
1826 | int 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 | */
|
---|
1963 | void 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 | */
|
---|
2008 | void 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 | */
|
---|
2039 | static 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 | */
|
---|
2062 | DECLHIDDEN(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 | */
|
---|
2141 | void 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 | */
|
---|
2151 | void 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 | */
|
---|
2167 | void 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 |
|
---|