Changeset 59700 in vbox for trunk/src/VBox/Devices/USB

Timestamp:

Feb 16, 2016 12:18:30 PM (9 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

105557

Message:

VUSB: Some structural cleanup (#2 Remove the HCI specific bits from the VUSBURB structure and let each controller manage it by itself just telling the root hub how much space it needs for each URB)

Location:

trunk/src/VBox/Devices/USB

Files:

• DevOHCI.cpp (modified) (31 diffs)
• DrvVUSBRootHub.cpp (modified) (8 diffs)
• USBProxyDevice.cpp (modified) (1 diff)
• VUSBInternal.h (modified) (1 diff)
• VUSBReadAhead.cpp (modified) (7 diffs)
• VUSBSnifferUsbMon.cpp (modified) (1 diff)
• VUSBUrb.cpp (modified) (8 diffs)

trunk/src/VBox/Devices/USB/DevOHCI.cpp

@@ -137 +137 @@
 typedef struct OHCI const *PCOHCI;
 
+#ifndef VBOX_DEVICE_STRUCT_TESTCASE
+/**
+ * Host controller transfer descriptor data.
+ */
+typedef struct VUSBURBHCITDINT
+{
+    /** Type of TD. */
+    uint32_t        TdType;
+    /** The address of the */
+    RTGCPHYS32      TdAddr;
+    /** A copy of the TD. */
+    uint32_t        TdCopy[16];
+} VUSBURBHCITDINT;
+
+/**
+ * The host controller data associated with each URB.
+ */
+typedef struct VUSBURBHCIINT
+{
+    /** The endpoint descriptor address. */
+    RTGCPHYS32      EdAddr;
+    /** Number of Tds in the array. */
+    uint32_t        cTds;
+    /** When this URB was created.
+     * (Used for isochronous frames and for logging.) */
+    uint32_t        u32FrameNo;
+    /** Flag indicating that the TDs have been unlinked. */
+    bool            fUnlinked;
+} VUSBURBHCIINT;
+#endif
 
 /**
@@ -1590 +1620 @@
     {
 #ifdef LOG_ENABLED
-        pUrb->Hci.u32FrameNo = pThis->HcFmNumber;
+        pUrb->pHci->u32FrameNo = pThis->HcFmNumber;
 #endif
         pThis->aInFlight[i].GCPhysTD = GCPhysTD;
@@ -1609 +1639 @@
 static void ohci_in_flight_add_urb(POHCI pThis, PVUSBURB pUrb)
 {
-    for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
-        ohci_in_flight_add(pThis, pUrb->Hci.paTds[iTd].TdAddr, pUrb);
+    for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
+        ohci_in_flight_add(pThis, pUrb->paTds[iTd].TdAddr, pUrb);
 }
 
@@ -1694 +1724 @@
     {
 #ifdef LOG_ENABLED
-        const int cFramesInFlight = pThis->HcFmNumber - pThis->aInFlight[i].pUrb->Hci.u32FrameNo;
+        const int cFramesInFlight = pThis->HcFmNumber - pThis->aInFlight[i].pUrb->pHci->u32FrameNo;
 #else
         const int cFramesInFlight = 0;
 #endif
         Log2(("ohci_in_flight_remove: reaping TD=%#010x %d frames (%#010x-%#010x)\n",
-              GCPhysTD, cFramesInFlight, pThis->aInFlight[i].pUrb->Hci.u32FrameNo, pThis->HcFmNumber));
+              GCPhysTD, cFramesInFlight, pThis->aInFlight[i].pUrb->pHci->u32FrameNo, pThis->HcFmNumber));
         pThis->aInFlight[i].GCPhysTD = 0;
         pThis->aInFlight[i].pUrb = NULL;
@@ -1720 +1750 @@
 static int ohci_in_flight_remove_urb(POHCI pThis, PVUSBURB pUrb)
 {
-    int cFramesInFlight = ohci_in_flight_remove(pThis, pUrb->Hci.paTds[0].TdAddr);
-    if (pUrb->Hci.cTds > 1)
-    {
-        for (unsigned iTd = 1; iTd < pUrb->Hci.cTds; iTd++)
-            if (ohci_in_flight_remove(pThis, pUrb->Hci.paTds[iTd].TdAddr) < 0)
+    int cFramesInFlight = ohci_in_flight_remove(pThis, pUrb->paTds[0].TdAddr);
+    if (pUrb->pHci->cTds > 1)
+    {
+        for (unsigned iTd = 1; iTd < pUrb->pHci->cTds; iTd++)
+            if (ohci_in_flight_remove(pThis, pUrb->paTds[iTd].TdAddr) < 0)
                 cFramesInFlight = -1;
     }
@@ -1955 +1985 @@
      * Don't unlink more than once.
      */
-    if (pUrb->Hci.fUnlinked)
+    if (pUrb->pHci->fUnlinked)
         return true;
-    pUrb->Hci.fUnlinked = true;
+    pUrb->pHci->fUnlinked = true;
 
     if (pUrb->enmType == VUSBXFERTYPE_ISOC)
     {
-        for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
+        for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
         {
-            POHCIITD pITd = (POHCIITD)&pUrb->Hci.paTds[iTd].TdCopy[0];
-            const uint32_t ITdAddr = pUrb->Hci.paTds[iTd].TdAddr;
+            POHCIITD pITd = (POHCIITD)&pUrb->paTds[iTd].TdCopy[0];
+            const uint32_t ITdAddr = pUrb->paTds[iTd].TdAddr;
 
             /*
@@ -1989 +2019 @@
     else
     {
-        for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
+        for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
         {
-            POHCITD pTd = (POHCITD)&pUrb->Hci.paTds[iTd].TdCopy[0];
-            const uint32_t TdAddr = pUrb->Hci.paTds[iTd].TdAddr;
+            POHCITD pTd = (POHCITD)&pUrb->paTds[iTd].TdCopy[0];
+            const uint32_t TdAddr = pUrb->paTds[iTd].TdAddr;
 
             /** @todo r=bird: Messing with the toggle flag in prepare is probably not correct
@@ -2078 +2108 @@
     if (!pEd)
     {
-        ohciReadEd(pThis, pUrb->Hci.EdAddr, &Ed);
+        ohciReadEd(pThis, pUrb->pHci->EdAddr, &Ed);
         pEd = &Ed;
     }
@@ -2084 +2114 @@
     if (pUrb->enmType == VUSBXFERTYPE_ISOC)
     {
-        for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
+        for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
         {
             union
@@ -2091 +2121 @@
                 uint32_t    au32[8];
             } u;
-            if (    (pUrb->Hci.paTds[iTd].TdAddr & ED_PTR_MASK)
+            if (    (pUrb->paTds[iTd].TdAddr & ED_PTR_MASK)
                 ==  (pEd->TailP & ED_PTR_MASK))
             {
                 Log(("%s: ohciHasUrbBeenCanceled: iTd=%d cTds=%d TdAddr=%#010RX32 canceled (tail)! [iso]\n",
-                     pUrb->pszDesc, iTd, pUrb->Hci.cTds, pUrb->Hci.paTds[iTd].TdAddr));
+                     pUrb->pszDesc, iTd, pUrb->pHci->cTds, pUrb->paTds[iTd].TdAddr));
                 STAM_COUNTER_INC(&pThis->StatCanceledIsocUrbs);
                 return true;
             }
-            ohciReadITd(pThis, pUrb->Hci.paTds[iTd].TdAddr, &u.ITd);
-            if (    u.au32[0] != pUrb->Hci.paTds[iTd].TdCopy[0]     /* hwinfo */
-                ||  u.au32[1] != pUrb->Hci.paTds[iTd].TdCopy[1]     /* bp0 */
-                ||  u.au32[3] != pUrb->Hci.paTds[iTd].TdCopy[3]     /* be */
-                ||  (   u.au32[2] != pUrb->Hci.paTds[iTd].TdCopy[2] /* NextTD */
-                     && iTd + 1 < pUrb->Hci.cTds /* ignore the last one */)
-                ||  u.au32[4] != pUrb->Hci.paTds[iTd].TdCopy[4]     /* psw0&1 */
-                ||  u.au32[5] != pUrb->Hci.paTds[iTd].TdCopy[5]     /* psw2&3 */
-                ||  u.au32[6] != pUrb->Hci.paTds[iTd].TdCopy[6]     /* psw4&5 */
-                ||  u.au32[7] != pUrb->Hci.paTds[iTd].TdCopy[7]     /* psw6&7 */
+            ohciReadITd(pThis, pUrb->paTds[iTd].TdAddr, &u.ITd);
+            if (    u.au32[0] != pUrb->paTds[iTd].TdCopy[0]     /* hwinfo */
+                ||  u.au32[1] != pUrb->paTds[iTd].TdCopy[1]     /* bp0 */
+                ||  u.au32[3] != pUrb->paTds[iTd].TdCopy[3]     /* be */
+                ||  (   u.au32[2] != pUrb->paTds[iTd].TdCopy[2] /* NextTD */
+                     && iTd + 1 < pUrb->pHci->cTds /* ignore the last one */)
+                ||  u.au32[4] != pUrb->paTds[iTd].TdCopy[4]     /* psw0&1 */
+                ||  u.au32[5] != pUrb->paTds[iTd].TdCopy[5]     /* psw2&3 */
+                ||  u.au32[6] != pUrb->paTds[iTd].TdCopy[6]     /* psw4&5 */
+                ||  u.au32[7] != pUrb->paTds[iTd].TdCopy[7]     /* psw6&7 */
                )
             {
                 Log(("%s: ohciHasUrbBeenCanceled: iTd=%d cTds=%d TdAddr=%#010RX32 canceled! [iso]\n",
-                     pUrb->pszDesc, iTd, pUrb->Hci.cTds, pUrb->Hci.paTds[iTd].TdAddr));
+                     pUrb->pszDesc, iTd, pUrb->pHci->cTds, pUrb->paTds[iTd].TdAddr));
                 Log2(("   %.*Rhxs (cur)\n"
                       "!= %.*Rhxs (copy)\n",
-                      sizeof(u.ITd), &u.ITd, sizeof(u.ITd), &pUrb->Hci.paTds[iTd].TdCopy[0]));
+                      sizeof(u.ITd), &u.ITd, sizeof(u.ITd), &pUrb->paTds[iTd].TdCopy[0]));
                 STAM_COUNTER_INC(&pThis->StatCanceledIsocUrbs);
                 return true;
             }
-            pUrb->Hci.paTds[iTd].TdCopy[2] = u.au32[2];
+            pUrb->paTds[iTd].TdCopy[2] = u.au32[2];
         }
     }
     else
     {
-        for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
+        for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
         {
             union
@@ -2131 +2161 @@
                 uint32_t    au32[4];
             } u;
-            if (    (pUrb->Hci.paTds[iTd].TdAddr & ED_PTR_MASK)
+            if (    (pUrb->paTds[iTd].TdAddr & ED_PTR_MASK)
                 ==  (pEd->TailP & ED_PTR_MASK))
             {
                 Log(("%s: ohciHasUrbBeenCanceled: iTd=%d cTds=%d TdAddr=%#010RX32 canceled (tail)!\n",
-                     pUrb->pszDesc, iTd, pUrb->Hci.cTds, pUrb->Hci.paTds[iTd].TdAddr));
+                     pUrb->pszDesc, iTd, pUrb->pHci->cTds, pUrb->paTds[iTd].TdAddr));
                 STAM_COUNTER_INC(&pThis->StatCanceledGenUrbs);
                 return true;
             }
-            ohciReadTd(pThis, pUrb->Hci.paTds[iTd].TdAddr, &u.Td);
-            if (    u.au32[0] != pUrb->Hci.paTds[iTd].TdCopy[0]     /* hwinfo */
-                ||  u.au32[1] != pUrb->Hci.paTds[iTd].TdCopy[1]     /* cbp */
-                ||  u.au32[3] != pUrb->Hci.paTds[iTd].TdCopy[3]     /* be */
-                ||  (   u.au32[2] != pUrb->Hci.paTds[iTd].TdCopy[2] /* NextTD */
-                     && iTd + 1 < pUrb->Hci.cTds /* ignore the last one */)
+            ohciReadTd(pThis, pUrb->paTds[iTd].TdAddr, &u.Td);
+            if (    u.au32[0] != pUrb->paTds[iTd].TdCopy[0]     /* hwinfo */
+                ||  u.au32[1] != pUrb->paTds[iTd].TdCopy[1]     /* cbp */
+                ||  u.au32[3] != pUrb->paTds[iTd].TdCopy[3]     /* be */
+                ||  (   u.au32[2] != pUrb->paTds[iTd].TdCopy[2] /* NextTD */
+                     && iTd + 1 < pUrb->pHci->cTds /* ignore the last one */)
                )
             {
                 Log(("%s: ohciHasUrbBeenCanceled: iTd=%d cTds=%d TdAddr=%#010RX32 canceled!\n",
-                     pUrb->pszDesc, iTd, pUrb->Hci.cTds, pUrb->Hci.paTds[iTd].TdAddr));
+                     pUrb->pszDesc, iTd, pUrb->pHci->cTds, pUrb->paTds[iTd].TdAddr));
                 Log2(("   %.*Rhxs (cur)\n"
                       "!= %.*Rhxs (copy)\n",
-                      sizeof(u.Td), &u.Td, sizeof(u.Td), &pUrb->Hci.paTds[iTd].TdCopy[0]));
+                      sizeof(u.Td), &u.Td, sizeof(u.Td), &pUrb->paTds[iTd].TdCopy[0]));
                 STAM_COUNTER_INC(&pThis->StatCanceledGenUrbs);
                 return true;
             }
-            pUrb->Hci.paTds[iTd].TdCopy[2] = u.au32[2];
+            pUrb->paTds[iTd].TdCopy[2] = u.au32[2];
         }
     }
@@ -2259 +2289 @@
      * Copy the data back (if IN operation) and update the TDs.
      */
-    for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
-    {
-        POHCIITD pITd = (POHCIITD)&pUrb->Hci.paTds[iTd].TdCopy[0];
-        const uint32_t ITdAddr = pUrb->Hci.paTds[iTd].TdAddr;
+    for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
+    {
+        POHCIITD pITd = (POHCIITD)&pUrb->paTds[iTd].TdCopy[0];
+        const uint32_t ITdAddr = pUrb->paTds[iTd].TdAddr;
         const unsigned cFrames = ((pITd->HwInfo & ITD_HWINFO_FC) >> ITD_HWINFO_FC_SHIFT) + 1;
-        unsigned       R = (pUrb->Hci.u32FrameNo & ITD_HWINFO_SF) - (pITd->HwInfo & ITD_HWINFO_SF);
+        unsigned       R = (pUrb->pHci->u32FrameNo & ITD_HWINFO_SF) - (pITd->HwInfo & ITD_HWINFO_SF);
         if (R >= 8)
             R = 0; /* submitted ahead of time. */
@@ -2385 +2415 @@
              "psw0=%x:%x psw1=%x:%x psw2=%x:%x psw3=%x:%x psw4=%x:%x psw5=%x:%x psw6=%x:%x psw7=%x:%x R=%d\n",
              pUrb->pszDesc, ITdAddr,
-             pUrb->Hci.EdAddr,
+             pUrb->pHci->EdAddr,
              pITd->HwInfo & ITD_HWINFO_SF, pThis->HcFmNumber,
              (pITd->HwInfo & ITD_HWINFO_CC) >> ITD_HWINFO_CC_SHIFT,
@@ -2414 +2444 @@
     unsigned cbLeft = pUrb->cbData;
     uint8_t *pb     = &pUrb->abData[0];
-    for (unsigned iTd = 0; iTd < pUrb->Hci.cTds; iTd++)
-    {
-        POHCITD pTd = (POHCITD)&pUrb->Hci.paTds[iTd].TdCopy[0];
-        const uint32_t TdAddr = pUrb->Hci.paTds[iTd].TdAddr;
+    for (unsigned iTd = 0; iTd < pUrb->pHci->cTds; iTd++)
+    {
+        POHCITD pTd = (POHCITD)&pUrb->paTds[iTd].TdCopy[0];
+        const uint32_t TdAddr = pUrb->paTds[iTd].TdAddr;
 
         /*
@@ -2473 +2503 @@
                 pThis->dqic = DoneInt;
             Log(("%s: ohciRhXferCompleteGeneralURB: ED=%#010x TD=%#010x Age=%d enmStatus=%d cbTotal=%#x NewCbp=%#010RX32 dqic=%d\n",
-                 pUrb->pszDesc, pUrb->Hci.EdAddr, TdAddr, cFmAge, pUrb->enmStatus, Buf.cbTotal, NewCbp, pThis->dqic));
+                 pUrb->pszDesc, pUrb->pHci->EdAddr, TdAddr, cFmAge, pUrb->enmStatus, Buf.cbTotal, NewCbp, pThis->dqic));
         }
         else
         {
             Log(("%s: ohciRhXferCompleteGeneralURB: HALTED ED=%#010x TD=%#010x (age %d) pUrb->enmStatus=%d\n",
-                 pUrb->pszDesc, pUrb->Hci.EdAddr, TdAddr, cFmAge, pUrb->enmStatus));
+                 pUrb->pszDesc, pUrb->pHci->EdAddr, TdAddr, cFmAge, pUrb->enmStatus));
             pEd->HeadP |= ED_HEAD_HALTED;
             pThis->dqic = 0; /* "If the Transfer Descriptor is being retired with an error,
@@ -2549 +2579 @@
     POHCI pThis = VUSBIROOTHUBPORT_2_OHCI(pInterface);
     LogFlow(("%s: ohciRhXferCompletion: EdAddr=%#010RX32 cTds=%d TdAddr0=%#010RX32\n",
-             pUrb->pszDesc, pUrb->Hci.EdAddr, pUrb->Hci.cTds, pUrb->Hci.paTds[0].TdAddr));
+             pUrb->pszDesc, pUrb->pHci->EdAddr, pUrb->pHci->cTds, pUrb->paTds[0].TdAddr));
 
     RTCritSectEnter(&pThis->CritSect);
@@ -2556 +2586 @@
     /* get the current end point descriptor. */
     OHCIED Ed;
-    ohciReadEd(pThis, pUrb->Hci.EdAddr, &Ed);
+    ohciReadEd(pThis, pUrb->pHci->EdAddr, &Ed);
 
     /*
@@ -2573 +2603 @@
         /* Leave the TD alone - the HCD doesn't want us talking to the device. */
         Log(("%s: ohciRhXferCompletion: CANCELED {ED=%#010x cTds=%d TD0=%#010x age %d}\n",
-             pUrb->pszDesc, pUrb->Hci.EdAddr, pUrb->Hci.cTds, pUrb->Hci.paTds[0].TdAddr, cFmAge));
+             pUrb->pszDesc, pUrb->pHci->EdAddr, pUrb->pHci->cTds, pUrb->paTds[0].TdAddr, cFmAge));
         STAM_COUNTER_INC(&pThis->StatDroppedUrbs);
         RTCritSectLeave(&pThis->CritSect);
@@ -2587 +2617 @@
     {
         Log(("%s: ohciRhXferCompletion: DROPPED {ED=%#010x cTds=%d TD0=%#010x age %d} because:%s%s%s%s%s!!!\n",
-             pUrb->pszDesc, pUrb->Hci.EdAddr, pUrb->Hci.cTds, pUrb->Hci.paTds[0].TdAddr, cFmAge,
+             pUrb->pszDesc, pUrb->pHci->EdAddr, pUrb->pHci->cTds, pUrb->paTds[0].TdAddr, cFmAge,
              (Ed.HeadP & ED_HEAD_HALTED)                            ? " ep halted" : "",
              (Ed.hwinfo & ED_HWINFO_SKIP)                           ? " ep skip" : "",
-             (Ed.HeadP & ED_PTR_MASK) != pUrb->Hci.paTds[0].TdAddr  ? " ep head-changed" : "",
+             (Ed.HeadP & ED_PTR_MASK) != pUrb->paTds[0].TdAddr      ? " ep head-changed" : "",
              cFmAge < 0                                             ? " td not-in-flight" : "",
              fHasBeenCanceled                                       ? " td canceled" : ""));
@@ -2609 +2639 @@
 
     /* finally write back the endpoint descriptor. */
-    ohciWriteEd(pThis, pUrb->Hci.EdAddr, &Ed);
+    ohciWriteEd(pThis, pUrb->pHci->EdAddr, &Ed);
 
     /* Calculate new frame rate and wakeup the framer thread if the rate was chnaged. */
@@ -2656 +2686 @@
      * This will make sure the TdCopy is up to date.
      */
-    const uint32_t  TdAddr = pUrb->Hci.paTds[0].TdAddr;
+    const uint32_t  TdAddr = pUrb->paTds[0].TdAddr;
 /** @todo IMPORTANT! we must check if the ED is still valid at this point!!! */
     if (ohciHasUrbBeenCanceled(pThis, pUrb, NULL))
@@ -2668 +2698 @@
          * Get and update the error counter.
          */
-        POHCITD     pTd = (POHCITD)&pUrb->Hci.paTds[0].TdCopy[0];
+        POHCITD     pTd = (POHCITD)&pUrb->paTds[0].TdCopy[0];
         unsigned    cErrs = (pTd->hwinfo & TD_HWINFO_ERRORS) >> TD_ERRORS_SHIFT;
         pTd->hwinfo &= ~TD_HWINFO_ERRORS;
@@ -2735 +2765 @@
     if (!pUrb)
         return false;                   /* retry later... */
-    Assert(pUrb->Hci.cTds == 1);
 
     pUrb->EndPt = (pEd->hwinfo & ED_HWINFO_ENDPOINT) >> ED_HWINFO_ENDPOINT_SHIFT;
     pUrb->fShortNotOk = !(Td.hwinfo & TD_HWINFO_ROUNDING);
     pUrb->enmStatus = VUSBSTATUS_OK;
-    pUrb->Hci.EdAddr = EdAddr;
-    pUrb->Hci.fUnlinked = false;
-    pUrb->Hci.paTds[0].TdAddr = TdAddr;
-    pUrb->Hci.u32FrameNo = pThis->HcFmNumber;
-    AssertCompile(sizeof(pUrb->Hci.paTds[0].TdCopy) >= sizeof(Td));
-    memcpy(pUrb->Hci.paTds[0].TdCopy, &Td, sizeof(Td));
+    pUrb->pHci->EdAddr = EdAddr;
+    pUrb->pHci->fUnlinked = false;
+    pUrb->pHci->cTds = 1;
+    pUrb->paTds[0].TdAddr = TdAddr;
+    pUrb->pHci->u32FrameNo = pThis->HcFmNumber;
+    AssertCompile(sizeof(pUrb->paTds[0].TdCopy) >= sizeof(Td));
+    memcpy(pUrb->paTds[0].TdCopy, &Td, sizeof(Td));
 
     /* copy data if out bound transfer. */
@@ -2888 +2918 @@
         /* retry later... */
         return false;
-    Assert(pUrb->Hci.cTds == cTds);
     Assert(pUrb->cbData == cbTotal);
 
@@ -2896 +2925 @@
     pUrb->fShortNotOk = !(pTail->Td.hwinfo & TD_HWINFO_ROUNDING);
     pUrb->enmStatus = VUSBSTATUS_OK;
-    pUrb->Hci.EdAddr = EdAddr;
-    pUrb->Hci.fUnlinked = false;
-    pUrb->Hci.u32FrameNo = pThis->HcFmNumber;
+    pUrb->pHci->cTds = cTds;
+    pUrb->pHci->EdAddr = EdAddr;
+    pUrb->pHci->fUnlinked = false;
+    pUrb->pHci->u32FrameNo = pThis->HcFmNumber;
 
     /* Copy data and TD information. */
@@ -2917 +2947 @@
 
         /* TD info */
-        pUrb->Hci.paTds[iTd].TdAddr = pCur->TdAddr;
-        AssertCompile(sizeof(pUrb->Hci.paTds[iTd].TdCopy) >= sizeof(pCur->Td));
-        memcpy(pUrb->Hci.paTds[iTd].TdCopy, &pCur->Td, sizeof(pCur->Td));
+        pUrb->paTds[iTd].TdAddr = pCur->TdAddr;
+        AssertCompile(sizeof(pUrb->paTds[iTd].TdCopy) >= sizeof(pCur->Td));
+        memcpy(pUrb->paTds[iTd].TdCopy, &pCur->Td, sizeof(pCur->Td));
     }
 
@@ -2985 +3015 @@
 
         /* Update the copy and write it back. */
-        POHCIITD pITdPrev = ((POHCIITD)pUrbPrev->Hci.paTds[0].TdCopy);
+        POHCIITD pITdPrev = ((POHCIITD)pUrbPrev->paTds[0].TdCopy);
         pITdPrev->NextTD = (pITdPrev->NextTD & ~ED_PTR_MASK) | ITdAddrNext;
         ohciWriteITd(pThis, ITdAddrPrev, pITdPrev, "ohciServiceIsochronousEndpoint");
@@ -3002 +3032 @@
     if (pUrb)
     {
-        pUrb->Hci.fUnlinked = true;
+        pUrb->pHci->fUnlinked = true;
         if (ohciHasUrbBeenCanceled(pThis, pUrb, pEd)) /* ensures the copy is correct (paranoia). */
             return false;
 
-        POHCIITD pITdCopy = ((POHCIITD)pUrb->Hci.paTds[0].TdCopy);
+        POHCIITD pITdCopy = ((POHCIITD)pUrb->paTds[0].TdCopy);
         pITd->NextTD = pITdCopy->NextTD &= ~ED_PTR_MASK;
     }
@@ -3097 +3127 @@
         return false;
 
-    pUrb->EndPt = (pEd->hwinfo & ED_HWINFO_ENDPOINT) >> ED_HWINFO_ENDPOINT_SHIFT;
-    pUrb->fShortNotOk = false;
-    pUrb->enmStatus = VUSBSTATUS_OK;
-    pUrb->Hci.EdAddr = EdAddr;
-    pUrb->Hci.fUnlinked = false;
-    pUrb->Hci.u32FrameNo = pThis->HcFmNumber;
-    pUrb->Hci.paTds[0].TdAddr = ITdAddr;
-    AssertCompile(sizeof(pUrb->Hci.paTds[0].TdCopy) >= sizeof(*pITd));
-    memcpy(pUrb->Hci.paTds[0].TdCopy, pITd, sizeof(*pITd));
+    pUrb->EndPt           = (pEd->hwinfo & ED_HWINFO_ENDPOINT) >> ED_HWINFO_ENDPOINT_SHIFT;
+    pUrb->fShortNotOk     = false;
+    pUrb->enmStatus       = VUSBSTATUS_OK;
+    pUrb->pHci->EdAddr    = EdAddr;
+    pUrb->pHci->cTds      = 1;
+    pUrb->pHci->fUnlinked = false;
+    pUrb->pHci->u32FrameNo = pThis->HcFmNumber;
+    pUrb->paTds[0].TdAddr = ITdAddr;
+    AssertCompile(sizeof(pUrb->paTds[0].TdCopy) >= sizeof(*pITd));
+    memcpy(pUrb->paTds[0].TdCopy, pITd, sizeof(*pITd));
 #if 0 /* color the data */
     memset(pUrb->abData, 0xfe, cbTotal);
@@ -5900 +5931 @@
     }
 
+    /* Set URB parameters. */
+    rc = VUSBIRhSetUrbParams(pThis->RootHub.pIRhConn, sizeof(VUSBURBHCIINT), sizeof(VUSBURBHCITDINT));
+    if (RT_FAILURE(rc))
+        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
+                                   N_("OHCI: Failed to set URB parameters"));
+
     /*
      * Calculate the timer intervals.
@@ -5914 +5951 @@
     if (RT_FAILURE(rc))
         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
-                                   N_("EHCI: Failed to create critical section"));
+                                   N_("OHCI: Failed to create critical section"));
 
     rc = RTSemEventMultiCreate(&pThis->hSemEventFrame);

trunk/src/VBox/Devices/USB/DrvVUSBRootHub.cpp

@@ -373 +373 @@
      * Reuse or allocate a new URB.
      */
+    /* Get the required amount of additional memory to allocate the whole state. */
+    size_t cbMem = RT_ALIGN_32(cbData, 16) + pRh->cbHci + cTds * pRh->cbHciTd;
+
     /** @todo try find a best fit, MSD which submits rather big URBs intermixed with small control
      * messages ends up with a 2+ of these big URBs when a single one is sufficient.  */
@@ -383 +386 @@
     while (pUrb)
     {
-        if (    pUrb->VUsb.cbDataAllocated >= cbData
-            &&  pUrb->VUsb.cTdsAllocated >= cTds)
+        if (pUrb->VUsb.cbDataAllocated >= cbData)
+        {
+            /* Unlink and verify part of the state. */
+            if (pUrbPrev)
+                pUrbPrev->VUsb.pNext = pUrb->VUsb.pNext;
+            else
+                pRh->pFreeUrbs = pUrb->VUsb.pNext;
+            Assert(pUrb->u32Magic == VUSBURB_MAGIC);
+            Assert(pUrb->VUsb.pvFreeCtx == pRh);
+            Assert(pUrb->VUsb.pfnFree == vusbRhFreeUrb);
+            Assert(pUrb->enmState == VUSBURBSTATE_FREE);
+            Assert(!pUrb->VUsb.pNext || pUrb->VUsb.pNext->enmState == VUSBURBSTATE_FREE);
             break;
+        }
         pUrbPrev = pUrb;
         pUrb = pUrb->VUsb.pNext;
     }
-    if (pUrb)
-    {
-        if (pUrbPrev)
-            pUrbPrev->VUsb.pNext = pUrb->VUsb.pNext;
-        else
-            pRh->pFreeUrbs = pUrb->VUsb.pNext;
-        Assert(pUrb->u32Magic == VUSBURB_MAGIC);
-        Assert(pUrb->VUsb.pvFreeCtx == pRh);
-        Assert(pUrb->VUsb.pfnFree == vusbRhFreeUrb);
-        Assert(pUrb->enmState == VUSBURBSTATE_FREE);
-        Assert(!pUrb->VUsb.pNext || pUrb->VUsb.pNext->enmState == VUSBURBSTATE_FREE);
-    }
-    else
+
+    if (!pUrb)
     {
         /* allocate a new one. */
-        uint32_t cbDataAllocated = cbData <= _4K  ? RT_ALIGN_32(cbData, _1K)
-                                 : cbData <= _32K ? RT_ALIGN_32(cbData, _4K)
-                                                  : RT_ALIGN_32(cbData, 16*_1K);
-        uint32_t cTdsAllocated = RT_ALIGN_32(cTds, 16);
-
-        pUrb = (PVUSBURB)RTMemAlloc(    RT_OFFSETOF(VUSBURB, abData[cbDataAllocated + 16])
-                                    +   sizeof(pUrb->Hci.paTds[0]) * cTdsAllocated);
+        uint32_t cbDataAllocated = cbMem <= _4K  ? RT_ALIGN_32(cbMem, _1K)
+                                 : cbMem <= _32K ? RT_ALIGN_32(cbMem, _4K)
+                                                 : RT_ALIGN_32(cbMem, 16*_1K);
+
+        pUrb = (PVUSBURB)RTMemAlloc(RT_OFFSETOF(VUSBURB, abData[cbDataAllocated]));
         if (RT_UNLIKELY(!pUrb))
         {
@@ -422 +423 @@
         pUrb->VUsb.pfnFree = vusbRhFreeUrb;
         pUrb->VUsb.cbDataAllocated = cbDataAllocated;
-        pUrb->VUsb.cTdsAllocated = cTdsAllocated;
-        pUrb->Hci.paTds = (VUSBURB::VUSBURBHCI::VUSBURBHCITD *)(&pUrb->abData[cbDataAllocated + 16]);
     }
     RTCritSectLeave(&pRh->CritSectFreeUrbs);
@@ -430 +429 @@
      * (Re)init the URB
      */
-    pUrb->enmState = VUSBURBSTATE_ALLOCATED;
-    pUrb->fCompleting = false;
-    pUrb->pszDesc = NULL;
-    pUrb->VUsb.pNext = NULL;
-    pUrb->VUsb.ppPrev = NULL;
-    pUrb->VUsb.pCtrlUrb = NULL;
+    pUrb->enmState         = VUSBURBSTATE_ALLOCATED;
+    pUrb->fCompleting      = false;
+    pUrb->pszDesc          = NULL;
+    pUrb->VUsb.pNext       = NULL;
+    pUrb->VUsb.ppPrev      = NULL;
+    pUrb->VUsb.pCtrlUrb    = NULL;
     pUrb->VUsb.u64SubmitTS = 0;
-    pUrb->VUsb.pDev = vusbRhFindDevByAddress(pRh, DstAddress);
-    pUrb->Hci.EdAddr = ~0;
-    pUrb->Hci.cTds = cTds;
-    pUrb->Hci.pNext = NULL;
-    pUrb->Hci.u32FrameNo = 0;
-    pUrb->Hci.fUnlinked = false;
-    pUrb->Dev.pvPrivate = NULL;
-    pUrb->Dev.pNext = NULL;
-    pUrb->pUsbIns = pUrb->VUsb.pDev ? pUrb->VUsb.pDev->pUsbIns : NULL;
-    pUrb->DstAddress = DstAddress;
-    pUrb->EndPt = ~0;
-    pUrb->enmType = enmType;
-    pUrb->enmDir = enmDir;
-    pUrb->fShortNotOk = false;
-    pUrb->enmStatus = VUSBSTATUS_INVALID;
-    pUrb->cbData = cbData;
+    pUrb->VUsb.pvReadAhead = NULL;
+    pUrb->VUsb.pDev        = vusbRhFindDevByAddress(pRh, DstAddress);
+    pUrb->Dev.pvPrivate    = NULL;
+    pUrb->Dev.pNext        = NULL;
+    pUrb->DstAddress       = DstAddress;
+    pUrb->EndPt            = ~0;
+    pUrb->enmType          = enmType;
+    pUrb->enmDir           = enmDir;
+    pUrb->fShortNotOk      = false;
+    pUrb->enmStatus        = VUSBSTATUS_INVALID;
+    pUrb->cbData           = cbData;
+    pUrb->pHci             = pRh->cbHci ? (PVUSBURBHCI)&pUrb->abData[cbData] : NULL;
+    pUrb->paTds            = (pRh->cbHciTd && cTds) ? (PVUSBURBHCITD)&pUrb->abData[cbData + pRh->cbHci] : NULL;
 
 #ifdef LOG_ENABLED
@@ -486 +482 @@
 
 
+/** @copydoc VUSBIROOTHUBCONNECTOR::pfnSetUrbParams */
+static DECLCALLBACK(int) vusbRhSetUrbParams(PVUSBIROOTHUBCONNECTOR pInterface, size_t cbHci, size_t cbHciTd)
+{
+    PVUSBROOTHUB pRh = VUSBIROOTHUBCONNECTOR_2_VUSBROOTHUB(pInterface);
+
+    pRh->cbHci   = cbHci;
+    pRh->cbHciTd = cbHciTd;
+
+    return VINF_SUCCESS;
+}
+
+
 /** @copydoc VUSBIROOTHUBCONNECTOR::pfnNewUrb */
 static DECLCALLBACK(PVUSBURB) vusbRhConnNewUrb(PVUSBIROOTHUBCONNECTOR pInterface, uint8_t DstAddress, VUSBXFERTYPE enmType,
@@ -545 +553 @@
      */
     int rc;
-    if (    pUrb->VUsb.pDev
-        &&  pUrb->pUsbIns)
+    if (   pUrb->VUsb.pDev
+        && pUrb->VUsb.pDev->pUsbIns)
     {
         switch (pUrb->enmDir)
@@ -1052 +1060 @@
     pThis->pDrvIns                      = pDrvIns;
     /* the connector */
+    pThis->IRhConnector.pfnSetUrbParams = vusbRhSetUrbParams;
     pThis->IRhConnector.pfnNewUrb       = vusbRhConnNewUrb;
     pThis->IRhConnector.pfnSubmitUrb    = vusbRhSubmitUrb;
@@ -1061 +1070 @@
     pThis->IRhConnector.pfnDetachDevice = vusbRhDetachDevice;
     pThis->hSniffer                     = VUSBSNIFFER_NIL;
+    pThis->cbHci                        = 0;
+    pThis->cbHciTd                      = 0;
 #ifdef LOG_ENABLED
     pThis->iSerial                      = 0;

trunk/src/VBox/Devices/USB/USBProxyDevice.cpp

@@ -67 +67 @@
         VUSBURB Urb;
         AssertCompile(RT_SIZEOFMEMB(VUSBURB, abData) >= _4K);
-        Urb.u32Magic = VUSBURB_MAGIC;
-        Urb.enmState = VUSBURBSTATE_IN_FLIGHT;
-        Urb.pszDesc = (char*)"URB sync";
-        memset(&Urb.VUsb, 0, sizeof(Urb.VUsb));
-        memset(&Urb.Hci, 0, sizeof(Urb.Hci));
+        Urb.u32Magic      = VUSBURB_MAGIC;
+        Urb.enmState      = VUSBURBSTATE_IN_FLIGHT;
+        Urb.pszDesc       = (char*)"URB sync";
+        Urb.pHci          = NULL;
+        Urb.paTds         = NULL;
         Urb.Dev.pvPrivate = NULL;
-        Urb.Dev.pNext = NULL;
-        Urb.pUsbIns = pProxyDev->pUsbIns;
-        Urb.DstAddress = 0;
-        Urb.EndPt = 0;
-        Urb.enmType = VUSBXFERTYPE_MSG;
-        Urb.enmDir = VUSBDIRECTION_IN;
-        Urb.fShortNotOk = false;
-        Urb.enmStatus = VUSBSTATUS_INVALID;
+        Urb.Dev.pNext     = NULL;
+        Urb.DstAddress    = 0;
+        Urb.EndPt         = 0;
+        Urb.enmType       = VUSBXFERTYPE_MSG;
+        Urb.enmDir        = VUSBDIRECTION_IN;
+        Urb.fShortNotOk   = false;
+        Urb.VUsb.pCtrlUrb = NULL;
+        Urb.enmStatus     = VUSBSTATUS_INVALID;
         cbHint = RT_MIN(cbHint, sizeof(Urb.abData) - sizeof(VUSBSETUP));
         Urb.cbData = cbHint + sizeof(VUSBSETUP);

trunk/src/VBox/Devices/USB/VUSBInternal.h

@@ -364 +364 @@
     /** Version of the attached Host Controller. */
     uint32_t                fHcVersions;
+    /** Size of the HCI specific data for each URB. */
+    size_t                  cbHci;
+    /** Size of the HCI specific TD. */
+    size_t                  cbHciTd;
 #ifdef LOG_ENABLED
     /** A serial number for URBs submitted on the roothub instance.

trunk/src/VBox/Devices/USB/VUSBReadAhead.cpp

@@ -110 +110 @@
         return NULL;
 
-    pUrb = vusbRhNewUrb(pRh, pDev->u8Address, VUSBXFERTYPE_ISOC, VUSBDIRECTION_IN, cbTotal, 1, NULL);
+    pUrb = vusbRhNewUrb(pRh, pDev->u8Address, VUSBXFERTYPE_ISOC, VUSBDIRECTION_IN, cbTotal, 1, "prab");
     if (!pUrb)
         /* not much we can do here... */
@@ -118 +118 @@
     pUrb->fShortNotOk           = false;
     pUrb->enmStatus             = VUSBSTATUS_OK;
-    pUrb->Hci.EdAddr            = 0;
-    pUrb->Hci.fUnlinked         = false;
-// @todo: fill in the rest? The Hci member is not relevant
-#ifdef LOG_ENABLED
-    static unsigned s_iSerial = 0;
-    s_iSerial = (s_iSerial + 1) % 10000;
-    RTStrAPrintf(&pUrb->pszDesc, "URB %p prab<%04d", pUrb, s_iSerial);  // prab = Periodic Read-Ahead Buffer
-#endif
 
     /* Set up the individual packets, again with bInterval in mind */
@@ -224 +216 @@
             Assert(pUrb->enmState == VUSBURBSTATE_ALLOCATED);
 
-            // @todo: at the moment we abuse the Hci.pNext member (which is otherwise entirely unused!)
-            pUrb->Hci.pNext = (PVUSBURB)pvUser;
-
+            pUrb->VUsb.pvReadAhead = pvUser;
             pUrb->enmState = VUSBURBSTATE_IN_FLIGHT;
             rc = vusbUrbQueueAsyncRh(pUrb);
@@ -260 +250 @@
         PVUSBURB pBufferedUrb = pThis->pBuffUrbHead;
 
-        pThis->pBuffUrbHead = pBufferedUrb->Hci.pNext;
+        pThis->pBuffUrbHead = (PVUSBURB)pBufferedUrb->VUsb.pvReadAhead;
         pBufferedUrb->VUsb.pfnFree(pBufferedUrb);
     }
@@ -279 +269 @@
 {
     Assert(pUrb);
-    Assert(pUrb->Hci.pNext);
-    PVUSBREADAHEADINT pThis = (PVUSBREADAHEADINT)pUrb->Hci.pNext;
+    Assert(pUrb->VUsb.pvReadAhead);
+    PVUSBREADAHEADINT pThis = (PVUSBREADAHEADINT)pUrb->VUsb.pvReadAhead;
     PVUSBPIPE         pPipe = pThis->pPipe;
     Assert(pPipe);
 
     RTCritSectEnter(&pThis->CritSectBuffUrbList);
-    pUrb->Hci.pNext = NULL; // @todo: use a more suitable field
+    pUrb->VUsb.pvReadAhead = NULL;
     if (pThis->pBuffUrbHead == NULL)
     {
@@ -296 +286 @@
         // Some URBs are queued already
         Assert(pThis->pBuffUrbTail);
-        Assert(!pThis->pBuffUrbTail->Hci.pNext);
-        pThis->pBuffUrbTail = pThis->pBuffUrbTail->Hci.pNext = pUrb;
+        Assert(!pThis->pBuffUrbTail->VUsb.pvReadAhead);
+        pThis->pBuffUrbTail->VUsb.pvReadAhead = pUrb;
+        pThis->pBuffUrbTail = pUrb;
     }
     ASMAtomicDecU32(&pThis->cSubmitted);
@@ -327 +318 @@
 
         // There's a URB available in the read-ahead buffer; use it
-        pThis->pBuffUrbHead = pBufferedUrb->Hci.pNext;
+        pThis->pBuffUrbHead = (PVUSBURB)pBufferedUrb->VUsb.pvReadAhead;
         if (pThis->pBuffUrbHead == NULL)
             pThis->pBuffUrbTail = NULL;

trunk/src/VBox/Devices/USB/VUSBSnifferUsbMon.cpp

@@ -175 +175 @@
 
                     cch += RTStrPrintf(&aszLineBuf[cch], sizeof(aszLineBuf) - cch, ":%u:%u:%u ",
-                                       1 /* Interval */, pUrb->Hci.u32FrameNo, u32ErrorCount);
+                                       1 /* Interval */, 0 /* Frame number */, u32ErrorCount);
                 }
                 else
                     cch += RTStrPrintf(&aszLineBuf[cch], sizeof(aszLineBuf) - cch, ":%u:%u ",
-                                       1 /* Interval */, pUrb->Hci.u32FrameNo);
+                                       1 /* Interval */, 0 /* Frame number */);
             }
             else if (pUrb->enmType == VUSBXFERTYPE_INTR)

trunk/src/VBox/Devices/USB/VUSBUrb.cpp

@@ -162 +162 @@
  * Logs an URB.
  *
- * Note that pUrb->pUsbIns, pUrb->VUsb.pDev and pUrb->VUsb.pDev->pUsbIns can all be NULL.
+ * Note that pUrb->VUsb.pDev and pUrb->VUsb.pDev->pUsbIns can all be NULL.
  */
 void vusbUrbTrace(PVUSBURB pUrb, const char *pszMsg, bool fComplete)
@@ -177 +177 @@
         s_cchMaxMsg = cchMsg;
 
-    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",
+    Log(("%s: %*s: pDev=%p[%s] rc=%s a=%i e=%u d=%s t=%s cb=%#x(%d) ts=%RU64 (%RU64 ns ago) %s\n",
          pUrb->pszDesc, s_cchMaxMsg, pszMsg,
          pDev,
-         pUrb->pUsbIns ? pUrb->pUsbIns->pszName : "",
+         pUrb->VUsb.pDev ? pUrb->VUsb.pDev->pUsbIns->pszName : "",
          vusbUrbStatusName(pUrb->enmStatus),
          pDev ? pDev->u8Address : -1,
@@ -188 +188 @@
          pUrb->cbData,
          pUrb->cbData,
-         pUrb->Hci.EdAddr,
-         pUrb->Hci.cTds,
-         pUrb->Hci.cTds ? pUrb->Hci.paTds[0].TdAddr : ~(uint32_t)0,
          pUrb->VUsb.u64SubmitTS,
          RTTimeNanoTS() - pUrb->VUsb.u64SubmitTS,
@@ -1171 +1168 @@
             return  pUrb->EndPt != 0                   /* not default control pipe */
                 ||  pSetup->wValue != 0                /* not ENDPOINT_HALT */
-                ||  !pUrb->pUsbIns->pReg->pfnUsbClearHaltedEndpoint; /* not special need for backend */
+                ||  !pUrb->VUsb.pDev->pUsbIns->pReg->pfnUsbClearHaltedEndpoint; /* not special need for backend */
         case VUSB_REQ_SET_ADDRESS:
         case VUSB_REQ_SET_CONFIGURATION:
@@ -1229 +1226 @@
 
     RTCritSectEnter(&pDev->CritSectAsyncUrbs);
-    int rc = pUrb->pUsbIns->pReg->pfnUrbQueue(pUrb->pUsbIns, pUrb);
+    int rc = pDev->pUsbIns->pReg->pfnUrbQueue(pDev->pUsbIns, pUrb);
     if (RT_FAILURE(rc))
     {
@@ -1416 +1413 @@
         //pExtra->Urb.Hci = {0};
         //pExtra->Urb.Dev.pvProxyUrb = NULL;
-        pExtra->Urb.pUsbIns = pUrb->pUsbIns;
         pExtra->Urb.DstAddress = pUrb->DstAddress;
         pExtra->Urb.EndPt = pUrb->EndPt;
@@ -2086 +2082 @@
 #ifdef VBOX_WITH_USB
     // Read-ahead URBs are handled differently
-    if (pUrb->Hci.pNext != NULL)
+    if (pUrb->VUsb.pvReadAhead)
         vusbUrbCompletionReadAhead(pUrb);
     else
@@ -2117 +2113 @@
 
         pUrb->enmState = VUSBURBSTATE_CANCELLED;
-        PPDMUSBINS pUsbIns = pUrb->pUsbIns;
+        PPDMUSBINS pUsbIns = pUrb->VUsb.pDev->pUsbIns;
         pUsbIns->pReg->pfnUrbCancel(pUsbIns, pUrb);
         Assert(pUrb->enmState == VUSBURBSTATE_CANCELLED || pUrb->enmState == VUSBURBSTATE_REAPED);