Changeset 82331 in vbox for trunk/src/VBox/Devices

Timestamp:

Dec 2, 2019 11:50:22 PM (5 years ago)

Author:

vboxsync

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

135155

Message:

DevHDA: Converted timers to new style. Left some todos. bugref:9218

Location:

trunk/src/VBox/Devices/Audio

Files:

• DevHDA.cpp (modified) (21 diffs)
• DevHDA.h (modified) (1 diff)
• DevHDACommon.cpp (modified) (5 diffs)
• DevHDACommon.h (modified) (1 diff)
• HDAStream.cpp (modified) (13 diffs)
• HDAStream.h (modified) (4 diffs)

trunk/src/VBox/Devices/Audio/DevHDA.cpp

@@ -157 +157 @@
 #define DEVHDA_LOCK_BOTH_RETURN(a_pDevIns, a_pThis, a_SD, a_rcBusy) \
     do { \
-        int rcLock = TMTimerLock((a_pThis)->pTimer[a_SD], (a_rcBusy)); \
-        if (rcLock == VINF_SUCCESS) \
-        { \
-            rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
-            if (rcLock == VINF_SUCCESS) \
-                break; \
-            TMTimerUnlock((a_pThis)->pTimer[a_SD]); \
-        } \
-        AssertRC(rcLock); \
-        return rcLock; \
+        VBOXSTRICTRC rcLock = PDMDevHlpTimerLockClock2(pDevIns, (a_pThis)->ahTimers[a_SD], &(a_pThis)->CritSect,  (a_rcBusy)); \
+        if (RT_LIKELY(rcLock == VINF_SUCCESS)) \
+        {  /* likely */ } \
+        else \
+            return VBOXSTRICTRC_TODO(rcLock); \
     } while (0)
 
@@ -173 +168 @@
  */
 #define DEVHDA_UNLOCK_BOTH(a_pDevIns, a_pThis, a_SD) \
-    do { \
-        PDMDevHlpCritSectLeave((a_pDevIns), &(a_pThis)->CritSect); \
-        TMTimerUnlock((a_pThis)->pTimer[a_SD]); \
-    } while (0)
+    PDMDevHlpTimerUnlockClock2(pDevIns, (a_pThis)->ahTimers[a_SD], &(a_pThis)->CritSect)
 
 
@@ -1400 +1392 @@
 # endif
                 /* (Re-)initialize the stream with current values. */
-                rc2 = hdaR3StreamInit(pStream, pStream->u8SD);
+                rc2 = hdaR3StreamInit(pDevIns, pStream, pStream->u8SD);
                 if (   RT_SUCCESS(rc2)
                     /* Any vital stream change occurred so that we need to (re-)add the stream to our setup?
@@ -1435 +1427 @@
                     AssertRC(rc2);
 
-                    rc2 = hdaR3TimerSet(pThis, pStream, TMTimerGet(pThis->pTimer[pStream->u8SD]) + pStream->State.cTransferTicks,
+                    rc2 = hdaR3TimerSet(pDevIns, pThis, pStream,
+                                          PDMDevHlpTimerGet(pDevIns, pThis->ahTimers[pStream->u8SD])
+                                        + pStream->State.cTransferTicks,
                                         false /* fForce */);
                     AssertRC(rc2);
@@ -1527 +1521 @@
     HDA_PROCESS_INTERRUPT(pDevIns, pThis);
 
-    const uint64_t tsNow = TMTimerGet(pThis->pTimer[uSD]);
+    const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pThis->ahTimers[uSD]);
     Assert(tsNow >= pStream->State.tsTransferLast);
 
@@ -1545 +1539 @@
 
         if (cTicksElapsed <= cTicksToNext)
-        {
             cTicksToNext = cTicksToNext - cTicksElapsed;
-        }
         else /* Catch up. */
         {
@@ -1555 +1547 @@
             LogRelMax2(64, ("HDA: Stream #%RU8 interrupt lagging behind (expected %uus, got %uus), trying to catch up ...\n",
                             pStream->u8SD,
-                            (TMTimerGetFreq(pThis->pTimer[pStream->u8SD]) / pThis->uTimerHz) / 1000,(tsNow - pStream->State.tsTransferLast) / 1000));
+                            (PDMDevHlpTimerGetFreq(pDevIns, pThis->ahTimers[pStream->u8SD]) / pThis->uTimerHz) / 1000,
+                            (tsNow - pStream->State.tsTransferLast) / 1000));
 
             cTicksToNext = 0;
@@ -1575 +1568 @@
             /* Re-arm the timer. */
             LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-            hdaR3TimerSet(pThis, pStream, tsNow + cTicksToNext, false /* fForce */);
+            hdaR3TimerSet(pDevIns, pThis, pStream, tsNow + cTicksToNext, false /* fForce */);
         }
     }
@@ -2845 +2838 @@
 
 /**
- * Main routine for the stream's timer.
- *
- * @param   pDevIns             Device instance.
- * @param   pTimer              Timer this callback was called for.
- * @param   pvUser              Pointer to associated HDASTREAM.
+ * @callback_method_impl{FNTMTIMERDEV, Main routine for the stream's timer.}
  */
 static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
-    PHDASTATE  pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-    PHDASTREAM pStream = (PHDASTREAM)pvUser;
+    PHDASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTREAM      pStream = (PHDASTREAM)pvUser;
+    TMTIMERHANDLE   hTimer  = RT_SAFE_SUBSCRIPT8(pThis->ahTimers, pStream->u8SD);
     RT_NOREF(pTimer);
 
     AssertPtr(pStream);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
-    Assert(TMTimerIsLockOwner(pStream->pTimer));
-
-    hdaR3StreamUpdate(pStream, true /* fInTimer */);
+    Assert(PDMDevHlpTimerIsLockOwner(pDevIns, hTimer));
+
+    hdaR3StreamUpdate(pDevIns, pStream, true /* fInTimer */);
 
     /* Flag indicating whether to kick the timer again for a new data processing round. */
@@ -2870 +2860 @@
     if (fSinkActive)
     {
-        const bool fTimerScheduled = hdaR3StreamTransferIsScheduled(pStream);
+        const bool fTimerScheduled = hdaR3StreamTransferIsScheduled(pDevIns, pStream);
         Log3Func(("fSinksActive=%RTbool, fTimerScheduled=%RTbool\n", fSinkActive, fTimerScheduled));
         if (!fTimerScheduled)
-            hdaR3TimerSet(pThis, pStream,
-                            TMTimerGet(pThis->pTimer[pStream->u8SD])
-                          + TMTimerGetFreq(pThis->pTimer[pStream->u8SD]) / pStream->pHDAState->uTimerHz,
+            hdaR3TimerSet(pDevIns, pThis, pStream,
+                            PDMDevHlpTimerGet(pDevIns, hTimer)
+                          + PDMDevHlpTimerGetFreq(pDevIns, hTimer) / pStream->pHDAState->uTimerHz,
                           true /* fForce */);
     }
@@ -3595 +3585 @@
  * Does required post processing when loading a saved state.
  *
+ * @param   pDevIns             The device instance.
  * @param   pThis               Pointer to HDA state.
  */
-static int hdaR3LoadExecPost(PHDASTATE pThis)
+static int hdaR3LoadExecPost(PPDMDEVINS pDevIns, PHDASTATE pThis)
 {
     int rc = VINF_SUCCESS;
@@ -3637 +3628 @@
                 hdaR3StreamRegisterDMAHandlers(pThis, pStream);
 #endif
-                if (hdaR3StreamTransferIsScheduled(pStream))
-                    hdaR3TimerSet(pThis, pStream, hdaR3StreamTransferGetNext(pStream), true /* fForce */);
+                if (hdaR3StreamTransferIsScheduled(pDevIns, pStream))
+                    hdaR3TimerSet(pDevIns, pThis, pStream, hdaR3StreamTransferGetNext(pStream), true /* fForce */);
 
                 /* Also keep track of the currently active streams. */
@@ -3749 +3740 @@
             /* Output */
             PHDASTREAM pStream = &pThis->aStreams[4];
-            rc = hdaR3StreamInit(pStream, 4 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pDevIns, pStream, 4 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
             rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
@@ -3758 +3749 @@
             /* Microphone-In */
             pStream = &pThis->aStreams[2];
-            rc = hdaR3StreamInit(pStream, 2 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pDevIns, pStream, 2 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
             rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
@@ -3767 +3758 @@
             /* Line-In */
             pStream = &pThis->aStreams[0];
-            rc = hdaR3StreamInit(pStream, 0 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pDevIns, pStream, 0 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
             rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
@@ -3805 +3796 @@
                 }
 
-                rc = hdaR3StreamInit(pStream, idStream);
+                rc = hdaR3StreamInit(pDevIns, pStream, idStream);
                 if (RT_FAILURE(rc))
                 {
@@ -3908 +3899 @@
         rc = hdaR3LoadExecLegacy(pDevIns, pThis, pSSM, uVersion);
         if (RT_SUCCESS(rc))
-            rc = hdaR3LoadExecPost(pThis);
+            rc = hdaR3LoadExecPost(pDevIns, pThis);
         return rc;
     }
@@ -3982 +3973 @@
         }
 
-        rc = hdaR3StreamInit(pStream, idStream);
+        rc = hdaR3StreamInit(pDevIns, pStream, idStream);
         if (RT_FAILURE(rc))
         {
@@ -4073 +4064 @@
     } /* for cStreams */
 
-    rc = hdaR3LoadExecPost(pThis);
+    rc = hdaR3LoadExecPost(pDevIns, pThis);
     AssertRC(rc);
 
@@ -4961 +4952 @@
 
     /*
-     * Create all hardware streams.
+     * Create the per stream timers and the asso.
+     *
+     * We must the critical section for the timers as the device has a
+     * noop section associated with it.
+     *
+     * Note:  Use TMCLOCK_VIRTUAL_SYNC here, as the guest's HDA driver relies
+     *        on exact (virtual) DMA timing and uses DMA Position Buffers
+     *        instead of the LPIB registers.
      */
     static const char * const s_apszNames[] =
@@ -4969 +4967 @@
     };
     AssertCompile(RT_ELEMENTS(s_apszNames) == HDA_MAX_STREAMS);
+    for (size_t i = 0; i < HDA_MAX_STREAMS; i++)
+    {
+        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, &pThis->aStreams[i],
+                                  TMTIMER_FLAGS_NO_CRIT_SECT, s_apszNames[i], &pThis->ahTimers[i]);
+        AssertRCReturn(rc, rc);
+
+        rc = PDMDevHlpTimerSetCritSect(pDevIns, pThis->ahTimers[i], &pThis->CritSect);
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
+     * Create all hardware streams.
+     */
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; ++i)
     {
-        /* Create the emulation timer (per stream).
-         *
-         * Note:  Use TMCLOCK_VIRTUAL_SYNC here, as the guest's HDA driver
-         *        relies on exact (virtual) DMA timing and uses DMA Position Buffers
-         *        instead of the LPIB registers.
-         */
-        rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, &pThis->aStreams[i],
-                                    TMTIMER_FLAGS_NO_CRIT_SECT, s_apszNames[i], &pThis->pTimer[i]);
-        AssertRCReturn(rc, rc);
-
-        /* Use our own critcal section for the device timer.
-         * That way we can control more fine-grained when to lock what. */
-        rc = TMR3TimerSetCritSect(pThis->pTimer[i], &pThis->CritSect);
-        AssertRCReturn(rc, rc);
-
         rc = hdaR3StreamCreate(&pThis->aStreams[i], pThis, i /* u8SD */);
         AssertRCReturn(rc, rc);

trunk/src/VBox/Devices/Audio/DevHDA.h

@@ -138 +138 @@
     /** Number of active (running) SDn streams. */
     uint8_t                 cStreamsActive;
-    /** The stream timers for pumping data thru the attached LUN drivers. */
-    PTMTIMERR3              pTimer[HDA_MAX_STREAMS];
+    /** The stream timers for pumping data thru the attached LUN drivers.
+     * Duplicated in HDASTREAM::hTimer. */
+    TMTIMERHANDLE           ahTimers[HDA_MAX_STREAMS];
     /** Pointer to HDA codec to use. */
     R3PTRTYPE(PHDACODEC)    pCodec;

trunk/src/VBox/Devices/Audio/DevHDACommon.cpp

@@ -2 +2 @@
 /** @file
  * DevHDACommon.cpp - Shared HDA device functions.
+ *
+ * @todo r=bird: Shared with whom exactly?
  */
 
@@ -662 +664 @@
  *
  * @returns Whether the new expiration time was set or not.
- * @param   pThis               HDA state.
- * @param   pStream             HDA stream to set timer for.
- * @param   tsExpire            New (virtual) expiration time to set.
- * @param   fForce              Whether to force setting the expiration time or not.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       HDA state.
+ * @param   pStream     HDA stream to set timer for.
+ * @param   tsExpire    New (virtual) expiration time to set.
+ * @param   fForce      Whether to force setting the expiration time or not.
  *
  * @remark  This function takes all active HDA streams and their
@@ -676 +679 @@
  *          Forcing a new expiration time will override the above mechanism.
  */
-bool hdaR3TimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t tsExpire, bool fForce)
-{
-    AssertPtrReturn(pThis, false);
-    AssertPtrReturn(pStream, false);
+bool hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStream, uint64_t tsExpire, bool fForce)
+{
+    AssertPtr(pThis);
+    AssertPtr(pStream);
 
     uint64_t tsExpireMin = tsExpire;
@@ -685 +688 @@
     if (!fForce)
     {
-        if (hdaR3StreamTransferIsScheduled(pStream))
-            tsExpireMin = RT_MIN(tsExpireMin, hdaR3StreamTransferGetNext(pStream));
-    }
-
-    AssertPtr(pThis->pTimer[pStream->u8SD]);
-
-    const uint64_t tsNow = TMTimerGet(pThis->pTimer[pStream->u8SD]);
+        /** @todo r=bird: hdaR3StreamTransferIsScheduled() also does a
+         * PDMDevHlpTimerGet(), so, some callers does one, this does, and then we do
+         * right afterwards == very inefficient! */
+        if (hdaR3StreamTransferIsScheduled(pDevIns, pStream))
+        {
+            uint64_t const tsNext = hdaR3StreamTransferGetNext(pStream);
+            if (tsExpireMin > tsNext)
+                tsExpireMin = tsNext;
+        }
+    }
+
+    const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
 
     /*
@@ -700 +708 @@
         tsExpireMin = tsNow;
 
-    int rc = TMTimerSet(pThis->pTimer[pStream->u8SD], tsExpireMin);
-    AssertRC(rc);
-
-    return RT_SUCCESS(rc);
+    int rc = PDMDevHlpTimerSet(pDevIns, pStream->hTimer, tsExpireMin);
+    AssertRCReturn(rc, false);
+
+    return true;
 }
 

trunk/src/VBox/Devices/Audio/DevHDACommon.h

@@ -653 +653 @@
  */
 #ifdef IN_RING3
-bool          hdaR3TimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t u64Expire, bool fForce);
-#endif /* IN_RING3 */
+bool          hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStream, uint64_t u64Expire, bool fForce);
+#endif
 /** @} */
 

trunk/src/VBox/Devices/Audio/HDAStream.cpp

@@ -54 +54 @@
     pStream->pMixSink       = NULL;
     pStream->pHDAState      = pThis;
-    pStream->pTimer         = pThis->pTimer[u8SD];
-    AssertPtr(pStream->pTimer);
+    pStream->hTimer         = pThis->ahTimers[u8SD];
 
     pStream->State.fInReset = false;
@@ -189 +188 @@
  * @returns IPRT status code. VINF_NO_CHANGE if the stream does not need (re-)initialization because the stream's (hardware)
  *          parameters did not change.
- * @param   pStream             HDA stream to initialize.
- * @param   uSD                 SD (stream descriptor) number to assign the HDA stream to.
- */
-int hdaR3StreamInit(PHDASTREAM pStream, uint8_t uSD)
+ * @param   pDevIns The device instance.
+ * @param   pStream HDA stream to initialize.
+ * @param   uSD     SD (stream descriptor) number to assign the HDA stream to.
+ */
+int hdaR3StreamInit(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint8_t uSD)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -464 +464 @@
                     pStream->State.cbTransferChunk = pStream->State.cbTransferSize;
 
-                const uint64_t cTicksPerHz = TMTimerGetFreq(pStream->pTimer) / pStream->State.uTimerHz;
+                const uint64_t cTicksPerHz = PDMDevHlpTimerGetFreq(pDevIns, pStream->hTimer) / pStream->State.uTimerHz;
 
                 /* Calculate the timer ticks per byte for this stream. */
@@ -715 +715 @@
 /**
  * Returns whether a next transfer for a given stream is scheduled or not.
+ *
  * This takes pending stream interrupts into account as well as the next scheduled
  * transfer timestamp.
  *
  * @returns True if a next transfer is scheduled, false if not.
+ * @param   pDevIns             The device instance.
  * @param   pStream             HDA stream to retrieve schedule status for.
  */
-bool hdaR3StreamTransferIsScheduled(PHDASTREAM pStream)
+bool hdaR3StreamTransferIsScheduled(PPDMDEVINS pDevIns, PHDASTREAM pStream)
 {
     if (pStream)
@@ -735 +737 @@
             }
 
-            const uint64_t tsNow = TMTimerGet(pStream->pTimer);
+            const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
             if (pStream->State.tsTransferNext > tsNow)
             {
@@ -908 +910 @@
  *
  * @returns IPRT status code.
+ * @param   pDevIns             The device instance.
  * @param   pStream             HDA stream to update.
  * @param   cbToProcessMax      How much data (in bytes) to process as maximum.
  */
-int hdaR3StreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax)
+int hdaR3StreamTransfer(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint32_t cbToProcessMax)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -945 +948 @@
     }
 
-    const uint64_t tsNow = TMTimerGet(pStream->pTimer);
+    const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
 
     if (!pStream->State.tsTransferLast)
@@ -1376 +1379 @@
 
         LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-        hdaR3TimerSet(pStream->pHDAState, pStream, tsTransferNext, false /* fForce */);
+        hdaR3TimerSet(pDevIns, pStream->pHDAState, pStream, tsTransferNext, false /* fForce */);
 
         pStream->State.tsTransferNext = tsTransferNext;
@@ -1413 +1416 @@
  * (with fInTimer set to @c false).
  *
- * @param   pStream             HDA stream to update.
- * @param   fInTimer            Whether to this function was called from the timer
- *                              context or an asynchronous I/O stream thread (if supported).
- */
-void hdaR3StreamUpdate(PHDASTREAM pStream, bool fInTimer)
+ * @param   pDevIns     The device instance.
+ * @param   pStream     HDA stream to update.
+ * @param   fInTimer    Whether to this function was called from the timer
+ *                      context or an asynchronous I/O stream thread (if supported).
+ */
+void hdaR3StreamUpdate(PPDMDEVINS pDevIns, PHDASTREAM pStream, bool fInTimer)
 {
     if (!pStream)
@@ -1446 +1450 @@
             {
                 /* Do the DMA transfer. */
-                rc2 = hdaR3StreamTransfer(pStream, cbStreamFree);
+                rc2 = hdaR3StreamTransfer(pDevIns, pStream, cbStreamFree);
                 AssertRC(rc2);
             }
@@ -1567 +1571 @@
             if (cbStreamUsed)
             {
-                rc2 = hdaR3StreamTransfer(pStream, cbStreamUsed);
+                rc2 = hdaR3StreamTransfer(pDevIns, pStream, cbStreamUsed);
                 AssertRC(rc2);
             }
@@ -1823 +1827 @@
     PHDASTREAMTHREADCTX pCtx = (PHDASTREAMTHREADCTX)pvUser;
     AssertPtr(pCtx);
-
     PHDASTREAM pStream = pCtx->pStream;
+
     AssertPtr(pStream);
-
-    PHDASTREAMSTATEAIO pAIO = &pCtx->pStream->State.AIO;
+    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+
+    PPDMDEVINS pDevIns = pCtx->pThis->pDevInsR3;
 
     ASMAtomicXchgBool(&pAIO->fStarted, true);
@@ -1853 +1858 @@
             }
 
-            hdaR3StreamUpdate(pStream, false /* fInTimer */);
+            hdaR3StreamUpdate(pDevIns, pStream, false /* fInTimer */);
 
             int rc3 = RTCritSectLeave(&pAIO->CritSect);

trunk/src/VBox/Devices/Audio/HDAStream.h

@@ -188 +188 @@
 
 /**
- * Structure for keeping a HDA stream (SDI / SDO).
+ * An HDA stream (SDI / SDO).
  *
- * Note: This HDA stream has nothing to do with a regular audio stream handled
- * by the audio connector or the audio mixer. This HDA stream is a serial data in/out
- * stream (SDI/SDO) defined in hardware and can contain multiple audio streams
- * in one single SDI/SDO (interleaving streams).
+ * @note This HDA stream has nothing to do with a regular audio stream handled
+ *       by the audio connector or the audio mixer. This HDA stream is a serial
+ *       data in/out stream (SDI/SDO) defined in hardware and can contain
+ *       multiple audio streams in one single SDI/SDO (interleaving streams).
  *
  * How a specific SDI/SDO is mapped to our internal audio streams relies on the
  * stream channel mappings.
  *
- * Contains only register values which do *not* change until a
- * stream reset occurs.
+ * Contains only register values which do *not* change until a stream reset
+ * occurs.
  */
 typedef struct HDASTREAM
@@ -235 +235 @@
     /** Pointer to HDA sink this stream is attached to. */
     R3PTRTYPE(PHDAMIXERSINK) pMixSink;
+    /** Stream's timer (copy of HDASTATE::ahTimers[u8SD]). */
+    TMTIMERHANDLE            hTimer;
     /** The stream'S critical section to serialize access. */
     RTCRITSECT               CritSect;
-    /** Pointer to the stream's timer. */
-    PTMTIMERR3               pTimer;
     /** Internal state of this stream. */
     HDASTREAMSTATE           State;
     /** Debug information. */
     HDASTREAMDBGINFO         Dbg;
-} HDASTREAM, *PHDASTREAM;
+} HDASTREAM;
+/** Pointer to an HDA stream (SDI / SDO).  */
+typedef HDASTREAM *PHDASTREAM;
 
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
@@ -263 +265 @@
 int               hdaR3StreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD);
 void              hdaR3StreamDestroy(PHDASTREAM pStream);
-int               hdaR3StreamInit(PHDASTREAM pStream, uint8_t uSD);
+int               hdaR3StreamInit(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint8_t uSD);
 void              hdaR3StreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD);
 int               hdaR3StreamEnable(PHDASTREAM pStream, bool fEnable);
@@ -270 +272 @@
 uint32_t          hdaR3StreamGetFree(PHDASTREAM pStream);
 uint32_t          hdaR3StreamGetUsed(PHDASTREAM pStream);
-bool              hdaR3StreamTransferIsScheduled(PHDASTREAM pStream);
+bool              hdaR3StreamTransferIsScheduled(PPDMDEVINS pDevIns, PHDASTREAM pStream);
 uint64_t          hdaR3StreamTransferGetNext(PHDASTREAM pStream);
-int               hdaR3StreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax);
+int               hdaR3StreamTransfer(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint32_t cbToProcessMax);
 void              hdaR3StreamLock(PHDASTREAM pStream);
 void              hdaR3StreamUnlock(PHDASTREAM pStream);
 int               hdaR3StreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead);
 int               hdaR3StreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
-void              hdaR3StreamUpdate(PHDASTREAM pStream, bool fAsync);
+void              hdaR3StreamUpdate(PPDMDEVINS pDevIns, PHDASTREAM pStream, bool fAsync);
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
 bool              hdaR3StreamRegisterDMAHandlers(PHDASTREAM pStream);