Changeset 71736 in vbox for trunk/src/VBox/Devices/Audio

Timestamp:

Apr 7, 2018 9:29:18 PM (7 years ago)

Author:

vboxsync

Message:

DevHDA: Use hdaR3 as prefix for ring-3 only methods to make it less complicated to follow code.

Location:

trunk/src/VBox/Devices/Audio

Files:

• DevHDA.cpp (modified) (112 diffs)
• DevHDACommon.cpp (modified) (14 diffs)
• DevHDACommon.h (modified) (8 diffs)
• HDAStream.cpp (modified) (67 diffs)
• HDAStream.h (modified) (3 diffs)
• HDAStreamChannel.cpp (modified) (7 diffs)
• HDAStreamChannel.h (modified) (1 diff)
• HDAStreamMap.cpp (modified) (6 diffs)
• HDAStreamMap.h (modified) (1 diff)
• HDAStreamPeriod.cpp (modified) (26 diffs)
• HDAStreamPeriod.h (modified) (1 diff)

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

@@ -297 +297 @@
 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
 #ifdef IN_RING3
-static void hdaGCTLReset(PHDASTATE pThis);
+static void hdaR3GCTLReset(PHDASTATE pThis);
 #endif
 
@@ -360 +360 @@
  */
 #ifdef IN_RING3
-static int                        hdaAddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
-static int                        hdaRemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
+static int                        hdaR3AddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
+static int                        hdaR3RemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
-static DECLCALLBACK(VBOXSTRICTRC) hdaDMAAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser);
+static DECLCALLBACK(VBOXSTRICTRC) hdaR3DMAAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys,
+                                                        void *pvBuf, size_t cbBuf,
+                                                        PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser);
 # endif
 #endif /* IN_RING3 */
@@ -570 +572 @@
  * @param   pThis               The HDA device state.
  */
-static void hdaReschedulePendingInterrupts(PHDASTATE pThis)
+static void hdaR3ReschedulePendingInterrupts(PHDASTATE pThis)
 {
     bool fInterrupt = false;
@@ -580 +582 @@
             continue;
 
-        if (   hdaStreamPeriodIsComplete    (&pStream->State.Period)
-            && hdaStreamPeriodNeedsInterrupt(&pStream->State.Period)
-            && hdaWalClkSet(pThis, hdaStreamPeriodGetAbsElapsedWalClk(&pStream->State.Period), false /* fForce */))
+        if (   hdaR3StreamPeriodIsComplete    (&pStream->State.Period)
+            && hdaR3StreamPeriodNeedsInterrupt(&pStream->State.Period)
+            && hdaR3WalClkSet(pThis, hdaR3StreamPeriodGetAbsElapsedWalClk(&pStream->State.Period), false /* fForce */))
         {
             fInterrupt = true;
@@ -658 +660 @@
  * @param   offReg              The register offset.
  */
-static int hdaRegLookupWithin(uint32_t offReg)
+static int hdaR3RegLookupWithin(uint32_t offReg)
 {
     /*
@@ -1010 +1012 @@
         HDA_REG(pThis, GCTL) &= ~HDA_GCTL_CRST;
 
-        hdaGCTLReset(pThis);
+        hdaR3GCTLReset(pThis);
 #else
         AssertFailedReturnStmt(DEVHDA_UNLOCK(pThis), VINF_IOM_R3_MMIO_WRITE);
@@ -1067 +1069 @@
  * @remark  Does not actually set the wall clock counter.
  */
-static uint64_t hdaWalClkGetMax(PHDASTATE pThis)
+static uint64_t hdaR3WalClkGetMax(PHDASTATE pThis)
 {
     const uint64_t u64WalClkCur       = ASMAtomicReadU64(&pThis->u64WalClk);
     const uint64_t u64FrontAbsWalClk  = pThis->SinkFront.pStream
-                                      ? hdaStreamPeriodGetAbsElapsedWalClk(&pThis->SinkFront.pStream->State.Period) : 0;
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkFront.pStream->State.Period) : 0;
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
 #  error "Implement me!"
 # endif
     const uint64_t u64LineInAbsWalClk = pThis->SinkLineIn.pStream
-                                      ? hdaStreamPeriodGetAbsElapsedWalClk(&pThis->SinkLineIn.pStream->State.Period) : 0;
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkLineIn.pStream->State.Period) : 0;
 # ifdef VBOX_WITH_HDA_MIC_IN
     const uint64_t u64MicInAbsWalClk  = pThis->SinkMicIn.pStream
-                                      ? hdaStreamPeriodGetAbsElapsedWalClk(&pThis->SinkMicIn.pStream->State.Period) : 0;
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkMicIn.pStream->State.Period) : 0;
 # endif
 
@@ -1107 +1109 @@
     *pu32Value = RT_LO_U32(ASMAtomicReadU64(&pThis->u64WalClk));
 
-    Log3Func(("%RU32 (max @ %RU64)\n",*pu32Value, hdaWalClkGetMax(pThis)));
+    Log3Func(("%RU32 (max @ %RU64)\n",*pu32Value, hdaR3WalClkGetMax(pThis)));
 
     DEVHDA_UNLOCK(pThis);
@@ -1353 +1355 @@
         LogFunc(("[SD%RU8] Reset enter\n", uSD));
 
-        hdaStreamLock(pStream);
+        hdaR3StreamLock(pStream);
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-        hdaStreamAsyncIOLock(pStream);
-        hdaStreamAsyncIOEnable(pStream, false /* fEnable */);
+        hdaR3StreamAsyncIOLock(pStream);
+        hdaR3StreamAsyncIOEnable(pStream, false /* fEnable */);
 # endif
         /* Make sure to remove the run bit before doing the actual stream reset. */
         HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_SDCTL_RUN;
 
-        hdaStreamReset(pThis, pStream, pStream->u8SD);
+        hdaR3StreamReset(pThis, pStream, pStream->u8SD);
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-        hdaStreamAsyncIOUnlock(pStream);
+        hdaR3StreamAsyncIOUnlock(pStream);
 # endif
-        hdaStreamUnlock(pStream);
+        hdaR3StreamUnlock(pStream);
     }
     else
@@ -1379 +1381 @@
             LogFunc(("[SD%RU8] State changed (fRun=%RTbool)\n", uSD, fRun));
 
-            hdaStreamLock(pStream);
+            hdaR3StreamLock(pStream);
 
             int rc2;
@@ -1385 +1387 @@
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
             if (fRun)
-                rc2 = hdaStreamAsyncIOCreate(pStream);
-
-            hdaStreamAsyncIOLock(pStream);
+                rc2 = hdaR3StreamAsyncIOCreate(pStream);
+
+            hdaR3StreamAsyncIOLock(pStream);
 # endif
             if (fRun)
             {
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-                hdaStreamAsyncIOEnable(pStream, fRun /* fEnable */);
+                hdaR3StreamAsyncIOEnable(pStream, fRun /* fEnable */);
 # endif
                 /* (Re-)initialize the stream with current values. */
-                rc2 = hdaStreamInit(pStream, pStream->u8SD);
+                rc2 = hdaR3StreamInit(pStream, pStream->u8SD);
                 AssertRC(rc2);
 
                 /* Remove the old stream from the device setup. */
-                hdaRemoveStream(pThis, &pStream->State.Cfg);
+                hdaR3RemoveStream(pThis, &pStream->State.Cfg);
 
                 /* Add the stream to the device setup. */
-                rc2 = hdaAddStream(pThis, &pStream->State.Cfg);
+                rc2 = hdaR3AddStream(pThis, &pStream->State.Cfg);
                 AssertRC(rc2);
             }
 
             /* Enable/disable the stream. */
-            rc2 = hdaStreamEnable(pStream, fRun /* fEnable */);
+            rc2 = hdaR3StreamEnable(pStream, fRun /* fEnable */);
             AssertRC(rc2);
 
@@ -1416 +1418 @@
 
                 /* (Re-)init the stream's period. */
-                hdaStreamPeriodInit(&pStream->State.Period,
-                                    pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
+                hdaR3StreamPeriodInit(&pStream->State.Period,
+                                      pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
 
                 /* Begin a new period for this stream. */
-                rc2 = hdaStreamPeriodBegin(&pStream->State.Period, hdaWalClkGetCurrent(pThis)/* Use current wall clock time */);
+                rc2 = hdaR3StreamPeriodBegin(&pStream->State.Period, hdaWalClkGetCurrent(pThis)/* Use current wall clock time */);
                 AssertRC(rc2);
 
-                rc2 = hdaTimerSet(pThis, pStream, TMTimerGet(pThis->pTimer[pStream->u8SD]) + pStream->State.cTransferTicks, false /* fForce */);
+                rc2 = hdaR3TimerSet(pThis, pStream, TMTimerGet(pThis->pTimer[pStream->u8SD]) + pStream->State.cTransferTicks, false /* fForce */);
                 AssertRC(rc2);
             }
@@ -1434 +1436 @@
 
                 /* Make sure to (re-)schedule outstanding (delayed) interrupts. */
-                hdaReschedulePendingInterrupts(pThis);
+                hdaR3ReschedulePendingInterrupts(pThis);
 
                 /* Reset the period. */
-                hdaStreamPeriodReset(&pStream->State.Period);
+                hdaR3StreamPeriodReset(&pStream->State.Period);
             }
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-            hdaStreamAsyncIOUnlock(pStream);
+            hdaR3StreamAsyncIOUnlock(pStream);
 # endif
             /* Make sure to leave the lock before (eventually) starting the timer. */
-            hdaStreamUnlock(pStream);
+            hdaR3StreamUnlock(pStream);
         }
     }
@@ -1477 +1479 @@
     }
 
-    hdaStreamLock(pStream);
+    hdaR3StreamLock(pStream);
 
     uint32_t v = HDA_REG_IND(pThis, iReg);
@@ -1492 +1494 @@
     PHDASTREAMPERIOD pPeriod = &pStream->State.Period;
 
-    if (hdaStreamPeriodLock(pPeriod))
-    {
-        const bool fNeedsInterrupt = hdaStreamPeriodNeedsInterrupt(pPeriod);
+    if (hdaR3StreamPeriodLock(pPeriod))
+    {
+        const bool fNeedsInterrupt = hdaR3StreamPeriodNeedsInterrupt(pPeriod);
         if (fNeedsInterrupt)
-            hdaStreamPeriodReleaseInterrupt(pPeriod);
-
-        if (hdaStreamPeriodIsComplete(pPeriod))
+            hdaR3StreamPeriodReleaseInterrupt(pPeriod);
+
+        if (hdaR3StreamPeriodIsComplete(pPeriod))
         {
             /* Make sure to try to update the WALCLK register if a period is complete.
              * Use the maximum WALCLK value all (active) streams agree to. */
-            const uint64_t uWalClkMax = hdaWalClkGetMax(pThis);
+            const uint64_t uWalClkMax = hdaR3WalClkGetMax(pThis);
             if (uWalClkMax > hdaWalClkGetCurrent(pThis))
-                hdaWalClkSet(pThis, uWalClkMax, false /* fForce */);
-
-            hdaStreamPeriodEnd(pPeriod);
+                hdaR3WalClkSet(pThis, uWalClkMax, false /* fForce */);
+
+            hdaR3StreamPeriodEnd(pPeriod);
 
             if (fRunning)
-                hdaStreamPeriodBegin(pPeriod, hdaWalClkGetCurrent(pThis) /* Use current wall clock time */);
-        }
-
-        hdaStreamPeriodUnlock(pPeriod); /* Unlock before processing interrupt. */
+                hdaR3StreamPeriodBegin(pPeriod, hdaWalClkGetCurrent(pThis) /* Use current wall clock time */);
+        }
+
+        hdaR3StreamPeriodUnlock(pPeriod); /* Unlock before processing interrupt. */
     }
 
@@ -1569 +1571 @@
             /* Re-arm the timer. */
             LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-            hdaTimerSet(pThis, pStream, tsNow + cTicksToNext, false /* fForce */);
-        }
-    }
-
-    hdaStreamUnlock(pStream);
+            hdaR3TimerSet(pThis, pStream, tsNow + cTicksToNext, false /* fForce */);
+        }
+    }
+
+    hdaR3StreamUnlock(pStream);
 
     DEVHDA_UNLOCK_BOTH(pThis, uSD);
@@ -1604 +1606 @@
                 /* Try registering the DMA handlers.
                  * As we can't be sure in which order LVI + BDL base are set, try registering in both routines. */
-                if (hdaStreamRegisterDMAHandlers(pThis, pStream))
+                if (hdaR3StreamRegisterDMAHandlers(pThis, pStream))
                     LogFunc(("[SD%RU8] DMA logging enabled\n", pStream->u8SD));
             }
@@ -1746 +1748 @@
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaAddStreamOut(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+static int hdaR3AddStreamOut(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -1883 +1885 @@
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaAddStreamIn(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+static int hdaR3AddStreamIn(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -1924 +1926 @@
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaAddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+static int hdaR3AddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -1936 +1938 @@
     {
         case PDMAUDIODIR_OUT:
-            rc = hdaAddStreamOut(pThis, pCfg);
+            rc = hdaR3AddStreamOut(pThis, pCfg);
             break;
 
         case PDMAUDIODIR_IN:
-            rc = hdaAddStreamIn(pThis, pCfg);
+            rc = hdaR3AddStreamIn(pThis, pCfg);
             break;
 
@@ -1961 +1963 @@
  * @param   pCfg                Stream configuration to use for removing a stream.
  */
-static int hdaRemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
+static int hdaR3RemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -2076 +2078 @@
         /* Try registering the DMA handlers.
          * As we can't be sure in which order LVI + BDL base are set, try registering in both routines. */
-        if (hdaStreamRegisterDMAHandlers(pThis, pStream))
+        if (hdaR3StreamRegisterDMAHandlers(pThis, pStream))
             LogFunc(("[SD%RU8] DMA logging enabled\n", pStream->u8SD));
     }
@@ -2307 +2309 @@
  * @param   enmMixerCtl         Mixer control to get the corresponding sink for.
  */
-static PHDAMIXERSINK hdaMixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
+static PHDAMIXERSINK hdaR3MixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
 {
     PHDAMIXERSINK pSink;
@@ -2352 +2354 @@
  * @param   pDrv                Driver stream to add.
  */
-static int hdaMixerAddDrvStream(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv)
+static int hdaR3MixerAddDrvStream(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv)
 {
     AssertPtrReturn(pThis,    VERR_INVALID_POINTER);
@@ -2445 +2447 @@
  * @param   pCfg                Audio stream configuration to use for the audio streams to add.
  */
-static int hdaMixerAddDrvStreams(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg)
+static int hdaR3MixerAddDrvStreams(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis,    VERR_INVALID_POINTER);
@@ -2463 +2465 @@
     RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
     {
-        int rc2 = hdaMixerAddDrvStream(pThis, pMixSink, pCfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThis, pMixSink, pCfg, pDrv);
         if (RT_FAILURE(rc2))
             LogFunc(("Attaching stream failed with %Rrc\n", rc2));
@@ -2487 +2489 @@
  * @param   pCfg                Stream configuration for the new stream.
  */
-static DECLCALLBACK(int) hdaMixerAddStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
+static DECLCALLBACK(int) hdaR3MixerAddStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -2494 +2496 @@
     int rc;
 
-    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
-        rc = hdaMixerAddDrvStreams(pThis, pSink->pMixSink, pCfg);
+        rc = hdaR3MixerAddDrvStreams(pThis, pSink->pMixSink, pCfg);
 
         AssertPtr(pSink->pMixSink);
@@ -2520 +2522 @@
  * @remarks Can be called as a callback by the HDA codec.
  */
-static DECLCALLBACK(int) hdaMixerRemoveStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
+static DECLCALLBACK(int) hdaR3MixerRemoveStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
 {
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
@@ -2526 +2528 @@
     int rc;
 
-    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
@@ -2603 +2605 @@
  * @remarks Can be called as a callback by the HDA codec.
  */
-static DECLCALLBACK(int) hdaMixerControl(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
+static DECLCALLBACK(int) hdaR3MixerControl(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
 {
     LogFunc(("enmMixerCtl=%s, uSD=%RU8, uChannel=%RU8\n", DrvAudioHlpAudMixerCtlToStr(enmMixerCtl), uSD, uChannel));
@@ -2630 +2632 @@
     int rc = VINF_SUCCESS;
 
-    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
     if (pSink)
     {
@@ -2651 +2653 @@
                      pSink->pMixSink->pszName, pSink->pStream->u8SD, pSink->pStream->u8Channel));
 
-            hdaStreamLock(pSink->pStream);
+            hdaR3StreamLock(pSink->pStream);
 
             /* Only disable the stream if the stream descriptor # has changed. */
             if (pSink->pStream->u8SD != uSD)
-                hdaStreamEnable(pSink->pStream, false);
+                hdaR3StreamEnable(pSink->pStream, false);
 
             pSink->pStream->pMixSink = NULL;
 
-            hdaStreamUnlock(pSink->pStream);
+            hdaR3StreamUnlock(pSink->pStream);
 
             pSink->pStream = NULL;
@@ -2676 +2678 @@
             if (pStream)
             {
-                hdaStreamLock(pStream);
+                hdaR3StreamLock(pStream);
 
                 pSink->pStream = pStream;
@@ -2683 +2685 @@
                 pStream->pMixSink  = pSink;
 
-                hdaStreamUnlock(pStream);
+                hdaR3StreamUnlock(pStream);
 
                 rc = VINF_SUCCESS;
@@ -2714 +2716 @@
  * @remarks Can be called as a callback by the HDA codec.
  */
-static DECLCALLBACK(int) hdaMixerSetVolume(PHDASTATE pThis,
-                                           PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol)
+static DECLCALLBACK(int) hdaR3MixerSetVolume(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol)
 {
     int rc;
 
-    PHDAMIXERSINK pSink = hdaMixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
     if (   pSink
         && pSink->pMixSink)
@@ -2744 +2745 @@
  * @param   pvUser              Pointer to associated HDASTREAM.
  */
-static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
     RT_NOREF(pDevIns, pTimer);
@@ -2755 +2756 @@
     DEVHDA_LOCK_BOTH_RETURN_VOID(pStream->pHDAState, pStream->u8SD);
 
-    hdaStreamUpdate(pStream, true /* fInTimer */);
+    hdaR3StreamUpdate(pStream, true /* fInTimer */);
 
     /* Flag indicating whether to kick the timer again for a
@@ -2762 +2763 @@
     if (fSinkActive)
     {
-        const bool fTimerScheduled = hdaStreamTransferIsScheduled(pStream);
+        const bool fTimerScheduled = hdaR3StreamTransferIsScheduled(pStream);
         Log3Func(("fSinksActive=%RTbool, fTimerScheduled=%RTbool\n", fSinkActive, fTimerScheduled));
         if (!fTimerScheduled)
-            hdaTimerSet(pThis, pStream,
-                          TMTimerGet(pThis->pTimer[pStream->u8SD])
-                        + TMTimerGetFreq(pThis->pTimer[pStream->u8SD]) / pStream->pHDAState->u16TimerHz,
-                        true /* fForce */);
+            hdaR3TimerSet(pThis, pStream,
+                            TMTimerGet(pThis->pTimer[pStream->u8SD])
+                          + TMTimerGetFreq(pThis->pTimer[pStream->u8SD]) / pStream->pHDAState->u16TimerHz,
+                          true /* fForce */);
     }
     else
@@ -2792 +2793 @@
  * @param   pvUser          User argument.
  */
-static DECLCALLBACK(VBOXSTRICTRC) hdaDMAAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys,
-                                                      void *pvBuf, size_t cbBuf,
-                                                      PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
+static DECLCALLBACK(VBOXSTRICTRC) hdaR3DMAAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys,
+                                                        void *pvBuf, size_t cbBuf,
+                                                        PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
 {
     RT_NOREF(pVM, pVCpu, pvPhys, pvBuf, enmOrigin);
@@ -2915 +2916 @@
  *
  */
-static void hdaGCTLReset(PHDASTATE pThis)
+static void hdaR3GCTLReset(PHDASTATE pThis)
 {
     LogFlowFuncEnter();
@@ -2975 +2976 @@
      */
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    hdaMixerControl(pThis, PDMAUDIOMIXERCTL_MIC_IN    , 1 /* SD0 */, 0 /* Channel */);
+    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_MIC_IN    , 1 /* SD0 */, 0 /* Channel */);
 # endif
-    hdaMixerControl(pThis, PDMAUDIOMIXERCTL_LINE_IN   , 1 /* SD0 */, 0 /* Channel */);
-
-    hdaMixerControl(pThis, PDMAUDIOMIXERCTL_FRONT     , 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_LINE_IN   , 1 /* SD0 */, 0 /* Channel */);
+
+    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_FRONT     , 5 /* SD4 */, 0 /* Channel */);
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    hdaMixerControl(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
-    hdaMixerControl(pThis, PDMAUDIOMIXERCTL_REAR      , 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_REAR      , 5 /* SD4 */, 0 /* Channel */);
 # endif
 
@@ -2998 +2999 @@
     for (uint8_t uSD = 0; uSD < HDA_MAX_STREAMS; ++uSD)
     {
-        int rc2 = hdaStreamEnable(&pThis->aStreams[uSD], false /* fEnable */);
+        int rc2 = hdaR3StreamEnable(&pThis->aStreams[uSD], false /* fEnable */);
         if (RT_SUCCESS(rc2))
         {
             /* Remove the RUN bit from SDnCTL in case the stream was in a running state before. */
             HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_SDCTL_RUN;
-            hdaStreamReset(pThis, &pThis->aStreams[uSD], uSD);
+            hdaR3StreamReset(pThis, &pThis->aStreams[uSD], uSD);
         }
     }
@@ -3267 +3268 @@
          * shifting out input values.
          */
-        if (idxRegDsc == -1 && (idxRegDsc = hdaRegLookupWithin(offReg)) != -1)
+        if (idxRegDsc == -1 && (idxRegDsc = hdaR3RegLookupWithin(offReg)) != -1)
         {
             uint32_t const cbBefore = offReg - g_aHdaRegMap[idxRegDsc].offset; Assert(cbBefore > 0 && cbBefore < 4);
@@ -3342 +3343 @@
  * @callback_method_impl{FNPCIIOREGIONMAP}
  */
-static DECLCALLBACK(int)  hdaPciIoRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
-                                            RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
+static DECLCALLBACK(int) hdaR3PciIoRegionMap(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t iRegion,
+                                             RTGCPHYS GCPhysAddress, RTGCPHYS cb, PCIADDRESSSPACE enmType)
 {
     RT_NOREF(iRegion, enmType);
-    PHDASTATE   pThis = RT_FROM_MEMBER(pPciDev, HDASTATE, PciDev);
+    PHDASTATE pThis = RT_FROM_MEMBER(pPciDev, HDASTATE, PciDev);
 
     /*
@@ -3381 +3382 @@
 
 
-/* Saved state callbacks. */
-
-static int hdaSaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStream)
+/* Saved state workers and callbacks. */
+
+static int hdaR3SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStream)
 {
     RT_NOREF(pDevIns);
@@ -3430 +3431 @@
 
         HDABDLE curBDLE;
-        rc = hdaBDLEFetch(pThis, &curBDLE, u64BaseDMA, pStream->State.uCurBDLE);
+        rc = hdaR3BDLEFetch(pThis, &curBDLE, u64BaseDMA, pStream->State.uCurBDLE);
         AssertRC(rc);
 
@@ -3506 +3507 @@
 
 #ifdef LOG_ENABLED
-    hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+    hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
 #endif
 
@@ -3515 +3516 @@
  * @callback_method_impl{FNSSMDEVSAVEEXEC}
  */
-static DECLCALLBACK(int) hdaSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) hdaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -3536 +3537 @@
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
     {
-        int rc = hdaSaveStream(pDevIns, pSSM, &pThis->aStreams[i]);
+        int rc = hdaR3SaveStream(pDevIns, pSSM, &pThis->aStreams[i]);
         AssertRCReturn(rc, rc);
     }
@@ -3548 +3549 @@
  * @param   pThis               Pointer to HDA state.
  */
-static int hdaLoadExecPost(PHDASTATE pThis)
+static int hdaR3LoadExecPost(PHDASTATE pThis)
 {
     int rc = VINF_SUCCESS;
@@ -3567 +3568 @@
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
                 /* Make sure to also create the async I/O thread before actually enabling the stream. */
-                rc2 = hdaStreamAsyncIOCreate(pStream);
+                rc2 = hdaR3StreamAsyncIOCreate(pStream);
                 AssertRC(rc2);
 
                 /* ... and enabling it. */
-                hdaStreamAsyncIOEnable(pStream, true /* fEnable */);
+                hdaR3StreamAsyncIOEnable(pStream, true /* fEnable */);
 #endif
                 /* Resume the stream's period. */
-                hdaStreamPeriodResume(&pStream->State.Period);
+                hdaR3StreamPeriodResume(&pStream->State.Period);
 
                 /* (Re-)enable the stream. */
-                rc2 = hdaStreamEnable(pStream, true /* fEnable */);
+                rc2 = hdaR3StreamEnable(pStream, true /* fEnable */);
                 AssertRC(rc2);
 
                 /* Add the stream to the device setup. */
-                rc2 = hdaAddStream(pThis, &pStream->State.Cfg);
+                rc2 = hdaR3AddStream(pThis, &pStream->State.Cfg);
                 AssertRC(rc2);
 
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
                 /* (Re-)install the DMA handler. */
-                hdaStreamRegisterDMAHandlers(pThis, pStream);
+                hdaR3StreamRegisterDMAHandlers(pThis, pStream);
 #endif
-                if (hdaStreamTransferIsScheduled(pStream))
-                    hdaTimerSet(pThis, pStream, hdaStreamTransferGetNext(pStream), true /* fForce */);
+                if (hdaR3StreamTransferIsScheduled(pStream))
+                    hdaR3TimerSet(pThis, pStream, hdaR3StreamTransferGetNext(pStream), true /* fForce */);
 
                 /* Also keep track of the currently active streams. */
@@ -3610 +3611 @@
  * @param   uPass               Loading stage to handle.
  */
-static int hdaLoadExecLegacy(PHDASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+static int hdaR3LoadExecLegacy(PHDASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
     RT_NOREF(uPass);
@@ -3727 +3728 @@
             /* Output */
             PHDASTREAM pStream = &pThis->aStreams[4];
-            rc = hdaStreamInit(pStream, 4 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pStream, 4 /* Stream descriptor, hardcoded */);
             if (RT_FAILURE(rc))
                 break;
@@ -3735 +3736 @@
             /* Microphone-In */
             pStream = &pThis->aStreams[2];
-            rc = hdaStreamInit(pStream, 2 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pStream, 2 /* Stream descriptor, hardcoded */);
             if (RT_FAILURE(rc))
                 break;
@@ -3743 +3744 @@
             /* Line-In */
             pStream = &pThis->aStreams[0];
-            rc = hdaStreamInit(pStream, 0 /* Stream descriptor, hardcoded */);
+            rc = hdaR3StreamInit(pStream, 0 /* Stream descriptor, hardcoded */);
             if (RT_FAILURE(rc))
                 break;
@@ -3780 +3781 @@
                 }
 
-                rc = hdaStreamInit(pStream, uStreamID);
+                rc = hdaR3StreamInit(pStream, uStreamID);
                 if (RT_FAILURE(rc))
                 {
@@ -3868 +3869 @@
                               HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
 #ifdef LOG_ENABLED
-                    hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+                    hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
 #endif
                 }
@@ -3883 +3884 @@
  * @callback_method_impl{FNSSMDEVLOADEXEC}
  */
-static DECLCALLBACK(int) hdaLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+static DECLCALLBACK(int) hdaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -3889 +3890 @@
     Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
 
-    LogRel2(("hdaLoadExec: uVersion=%RU32, uPass=0x%x\n", uVersion, uPass));
+    LogRel2(("hdaR3LoadExec: uVersion=%RU32, uPass=0x%x\n", uVersion, uPass));
 
     /*
@@ -3903 +3904 @@
     if (uVersion < HDA_SSM_VERSION) /* Handle older saved states? */
     {
-        rc = hdaLoadExecLegacy(pThis, pSSM, uVersion, uPass);
+        rc = hdaR3LoadExecLegacy(pThis, pSSM, uVersion, uPass);
         if (RT_SUCCESS(rc))
-            rc = hdaLoadExecPost(pThis);
+            rc = hdaR3LoadExecPost(pThis);
 
         return rc;
@@ -3976 +3977 @@
         }
 
-        rc = hdaStreamInit(pStream, uStreamID);
+        rc = hdaR3StreamInit(pStream, uStreamID);
         if (RT_FAILURE(rc))
         {
@@ -4005 +4006 @@
          * Don't annoy other team mates (forgot this for state v7).
          */
-        hdaStreamPeriodInit(&pStream->State.Period,
-                            pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
+        hdaR3StreamPeriodInit(&pStream->State.Period,
+                              pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
 
         if (   SSMR3HandleRevision(pSSM) >= 116273
@@ -4072 +4073 @@
                   HDA_STREAM_REG(pThis, LPIB, uStreamID), HDA_STREAM_REG(pThis, CBL, uStreamID), HDA_STREAM_REG(pThis, LVI, uStreamID)));
 #ifdef LOG_ENABLED
-        hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+        hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
 #endif
         /** @todo (Re-)initialize active periods? */
@@ -4078 +4079 @@
     } /* for cStreams */
 
-    rc = hdaLoadExecPost(pThis);
+    rc = hdaR3LoadExecPost(pThis);
     AssertRC(rc);
 
@@ -4085 +4086 @@
 }
 
-/* Debug and log type formatters. */
+/* IPRT format type handlers. */
 
 /**
  * @callback_method_impl{FNRTSTRFORMATTYPE}
  */
-static DECLCALLBACK(size_t) hdaDbgFmtBDLE(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
-                                          const char *pszType, void const *pvValue,
-                                          int cchWidth, int cchPrecision, unsigned fFlags,
-                                          void *pvUser)
+static DECLCALLBACK(size_t) hdaR3StrFmtBDLE(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+                                            const char *pszType, void const *pvValue,
+                                            int cchWidth, int cchPrecision, unsigned fFlags,
+                                            void *pvUser)
 {
     RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
@@ -4106 +4107 @@
  * @callback_method_impl{FNRTSTRFORMATTYPE}
  */
-static DECLCALLBACK(size_t) hdaDbgFmtSDCTL(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
-                                           const char *pszType, void const *pvValue,
-                                           int cchWidth, int cchPrecision, unsigned fFlags,
-                                           void *pvUser)
+static DECLCALLBACK(size_t) hdaR3StrFmtSDCTL(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+                                             const char *pszType, void const *pvValue,
+                                             int cchWidth, int cchPrecision, unsigned fFlags,
+                                             void *pvUser)
 {
     RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
@@ -4129 +4130 @@
  * @callback_method_impl{FNRTSTRFORMATTYPE}
  */
-static DECLCALLBACK(size_t) hdaDbgFmtSDFIFOS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+static DECLCALLBACK(size_t) hdaR3StrFmtSDFIFOS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+                                               const char *pszType, void const *pvValue,
+                                               int cchWidth, int cchPrecision, unsigned fFlags,
+                                               void *pvUser)
+{
+    RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
+    uint32_t uSDFIFOS = (uint32_t)(uintptr_t)pvValue;
+    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOS(raw:%#x, sdfifos:%RU8 B)", uSDFIFOS, uSDFIFOS ? uSDFIFOS + 1 : 0);
+}
+
+/**
+ * @callback_method_impl{FNRTSTRFORMATTYPE}
+ */
+static DECLCALLBACK(size_t) hdaR3StrFmtSDFIFOW(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
+                                               const char *pszType, void const *pvValue,
+                                               int cchWidth, int cchPrecision, unsigned fFlags,
+                                               void *pvUser)
+{
+    RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
+    uint32_t uSDFIFOW = (uint32_t)(uintptr_t)pvValue;
+    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOW(raw: %#0x, sdfifow:%d B)", uSDFIFOW, hdaSDFIFOWToBytes(uSDFIFOW));
+}
+
+/**
+ * @callback_method_impl{FNRTSTRFORMATTYPE}
+ */
+static DECLCALLBACK(size_t) hdaR3StrFmtSDSTS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
                                              const char *pszType, void const *pvValue,
                                              int cchWidth, int cchPrecision, unsigned fFlags,
                                              void *pvUser)
-{
-    RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
-    uint32_t uSDFIFOS = (uint32_t)(uintptr_t)pvValue;
-    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOS(raw:%#x, sdfifos:%RU8 B)", uSDFIFOS, uSDFIFOS ? uSDFIFOS + 1 : 0);
-}
-
-/**
- * @callback_method_impl{FNRTSTRFORMATTYPE}
- */
-static DECLCALLBACK(size_t) hdaDbgFmtSDFIFOW(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
-                                             const char *pszType, void const *pvValue,
-                                             int cchWidth, int cchPrecision, unsigned fFlags,
-                                             void *pvUser)
-{
-    RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
-    uint32_t uSDFIFOW = (uint32_t)(uintptr_t)pvValue;
-    return RTStrFormat(pfnOutput, pvArgOutput, NULL, 0, "SDFIFOW(raw: %#0x, sdfifow:%d B)", uSDFIFOW, hdaSDFIFOWToBytes(uSDFIFOW));
-}
-
-/**
- * @callback_method_impl{FNRTSTRFORMATTYPE}
- */
-static DECLCALLBACK(size_t) hdaDbgFmtSDSTS(PFNRTSTROUTPUT pfnOutput, void *pvArgOutput,
-                                           const char *pszType, void const *pvValue,
-                                           int cchWidth, int cchPrecision, unsigned fFlags,
-                                           void *pvUser)
 {
     RT_NOREF(pszType, cchWidth,  cchPrecision, fFlags, pvUser);
@@ -4171 +4172 @@
 }
 
-static int hdaDbgLookupRegByName(const char *pszArgs)
+/* Debug info dumpers */
+
+static int hdaR3DbgLookupRegByName(const char *pszArgs)
 {
     int iReg = 0;
@@ -4181 +4184 @@
 
 
-static void hdaDbgPrintRegister(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iHdaIndex)
+static void hdaR3DbgPrintRegister(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iHdaIndex)
 {
     Assert(   pThis
@@ -4192 +4195 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
-    int iHdaRegisterIndex = hdaDbgLookupRegByName(pszArgs);
+    int iHdaRegisterIndex = hdaR3DbgLookupRegByName(pszArgs);
     if (iHdaRegisterIndex != -1)
-        hdaDbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
+        hdaR3DbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
     else
     {
         for(iHdaRegisterIndex = 0; (unsigned int)iHdaRegisterIndex < HDA_NUM_REGS; ++iHdaRegisterIndex)
-            hdaDbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
-    }
-}
-
-static void hdaDbgPrintStream(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
+            hdaR3DbgPrintRegister(pThis, pHlp, iHdaRegisterIndex);
+    }
+}
+
+static void hdaR3DbgPrintStream(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
 {
     Assert(   pThis
@@ -4221 +4224 @@
 }
 
-static void hdaDbgPrintBDLE(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
+static void hdaR3DbgPrintBDLE(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
 {
     Assert(   pThis
@@ -4278 +4281 @@
 }
 
-static int hdaDbgLookupStrmIdx(PHDASTATE pThis, const char *pszArgs)
+static int hdaR3DbgLookupStrmIdx(PHDASTATE pThis, const char *pszArgs)
 {
     RT_NOREF(pThis, pszArgs);
@@ -4288 +4291 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfoStream(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfoStream(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE   pThis         = PDMINS_2_DATA(pDevIns, PHDASTATE);
-    int         iHdaStreamdex = hdaDbgLookupStrmIdx(pThis, pszArgs);
+    int         iHdaStreamdex = hdaR3DbgLookupStrmIdx(pThis, pszArgs);
     if (iHdaStreamdex != -1)
-        hdaDbgPrintStream(pThis, pHlp, iHdaStreamdex);
+        hdaR3DbgPrintStream(pThis, pHlp, iHdaStreamdex);
     else
         for(iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
-            hdaDbgPrintStream(pThis, pHlp, iHdaStreamdex);
+            hdaR3DbgPrintStream(pThis, pHlp, iHdaStreamdex);
 }
 
@@ -4302 +4305 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfoBDLE(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfoBDLE(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE   pThis         = PDMINS_2_DATA(pDevIns, PHDASTATE);
-    int         iHdaStreamdex = hdaDbgLookupStrmIdx(pThis, pszArgs);
+    int         iHdaStreamdex = hdaR3DbgLookupStrmIdx(pThis, pszArgs);
     if (iHdaStreamdex != -1)
-        hdaDbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
+        hdaR3DbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
     else
-        for(iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
-            hdaDbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
+        for (iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
+            hdaR3DbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
 }
 
@@ -4316 +4319 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfoCodecNodes(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfoCodecNodes(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4329 +4332 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfoCodecSelector(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfoCodecSelector(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4342 +4345 @@
  * @callback_method_impl{FNDBGFHANDLERDEV}
  */
-static DECLCALLBACK(void) hdaDbgInfoMixer(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
+static DECLCALLBACK(void) hdaR3DbgInfoMixer(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4358 +4361 @@
  * @interface_method_impl{PDMIBASE,pfnQueryInterface}
  */
-static DECLCALLBACK(void *) hdaQueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
+static DECLCALLBACK(void *) hdaR3QueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
 {
     PHDASTATE pThis = RT_FROM_MEMBER(pInterface, HDASTATE, IBase);
@@ -4383 +4386 @@
  * @param   ppDrv       Attached driver instance on success. Optional.
  */
-static int hdaAttachInternal(PHDASTATE pThis, unsigned uLUN, uint32_t fFlags, PHDADRIVER *ppDrv)
+static int hdaR3AttachInternal(PHDASTATE pThis, unsigned uLUN, uint32_t fFlags, PHDADRIVER *ppDrv)
 {
     RT_NOREF(fFlags);
@@ -4455 +4458 @@
  * @param   fFlags      Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
  */
-static int hdaDetachInternal(PHDASTATE pThis, PHDADRIVER pDrv, uint32_t fFlags)
+static int hdaR3DetachInternal(PHDASTATE pThis, PHDADRIVER pDrv, uint32_t fFlags)
 {
     RT_NOREF(fFlags);
@@ -4492 +4495 @@
  * @interface_method_impl{PDMDEVREG,pfnAttach}
  */
-static DECLCALLBACK(int) hdaAttach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
+static DECLCALLBACK(int) hdaR3Attach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4501 +4504 @@
 
     PHDADRIVER pDrv;
-    int rc2 = hdaAttachInternal(pThis, uLUN, fFlags, &pDrv);
+    int rc2 = hdaR3AttachInternal(pThis, uLUN, fFlags, &pDrv);
     if (RT_SUCCESS(rc2))
     {
-        PHDASTREAM pStream = hdaGetStreamFromSink(pThis, &pThis->SinkFront);
+        PHDASTREAM pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkFront);
         if (DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
-            hdaMixerAddDrvStream(pThis, pThis->SinkFront.pMixSink,     &pStream->State.Cfg, pDrv);
+            hdaR3MixerAddDrvStream(pThis, pThis->SinkFront.pMixSink,     &pStream->State.Cfg, pDrv);
 
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-        pStream = hdaGetStreamFromSink(pThis, &pThis->SinkCenterLFE);
+        pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkCenterLFE);
         if (DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
-            hdaMixerAddDrvStream(pThis, pThis->SinkCenterLFE.pMixSink, &pStream->State.Cfg, pDrv);
-
-        pStream = hdaGetStreamFromSink(pThis, &pThis->SinkRear);
+            hdaR3MixerAddDrvStream(pThis, pThis->SinkCenterLFE.pMixSink, &pStream->State.Cfg, pDrv);
+
+        pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkRear);
         if (DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
-            hdaMixerAddDrvStream(pThis, pThis->SinkRear.pMixSink,      &pStream->State.Cfg, pDrv);
+            hdaR3MixerAddDrvStream(pThis, pThis->SinkRear.pMixSink,      &pStream->State.Cfg, pDrv);
 #endif
-        pStream = hdaGetStreamFromSink(pThis, &pThis->SinkLineIn);
+        pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn);
         if (DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
-            hdaMixerAddDrvStream(pThis, pThis->SinkLineIn.pMixSink,    &pStream->State.Cfg, pDrv);
+            hdaR3MixerAddDrvStream(pThis, pThis->SinkLineIn.pMixSink,    &pStream->State.Cfg, pDrv);
 
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-        pStream = hdaGetStreamFromSink(pThis, &pThis->SinkMicIn);
+        pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn);
         if (DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
-            hdaMixerAddDrvStream(pThis, pThis->SinkMicIn.pMixSink,     &pStream->State.Cfg, pDrv);
+            hdaR3MixerAddDrvStream(pThis, pThis->SinkMicIn.pMixSink,     &pStream->State.Cfg, pDrv);
 #endif
     }
@@ -4536 +4539 @@
  * @interface_method_impl{PDMDEVREG,pfnDetach}
  */
-static DECLCALLBACK(void) hdaDetach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
+static DECLCALLBACK(void) hdaR3Detach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4549 +4552 @@
         if (pDrv->uLUN == uLUN)
         {
-            int rc2 = hdaDetachInternal(pThis, pDrv, fFlags);
+            int rc2 = hdaR3DetachInternal(pThis, pDrv, fFlags);
             if (RT_SUCCESS(rc2))
             {
@@ -4568 +4571 @@
  * @param   pDevIns             Device instance to power off.
  */
-static DECLCALLBACK(void) hdaPowerOff(PPDMDEVINS pDevIns)
+static DECLCALLBACK(void) hdaR3PowerOff(PPDMDEVINS pDevIns)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4580 +4583 @@
 
     /*
-     * Note: Destroy the mixer while powering off and *not* in hdaDestruct,
+     * Note: Destroy the mixer while powering off and *not* in hdaR3Destruct,
      *       giving the mixer the chance to release any references held to
      *       PDM audio streams it maintains.
@@ -4608 +4611 @@
  * @param   pszDriver   New driver name to attach.
  */
-static int hdaReattachInternal(PHDASTATE pThis, PHDADRIVER pDrv, uint8_t uLUN, const char *pszDriver)
+static int hdaR3ReattachInternal(PHDASTATE pThis, PHDADRIVER pDrv, uint8_t uLUN, const char *pszDriver)
 {
     AssertPtrReturn(pThis,     VERR_INVALID_POINTER);
@@ -4617 +4620 @@
     if (pDrv)
     {
-        rc = hdaDetachInternal(pThis, pDrv, 0 /* fFlags */);
+        rc = hdaR3DetachInternal(pThis, pDrv, 0 /* fFlags */);
         if (RT_SUCCESS(rc))
             rc = PDMDevHlpDriverDetach(pThis->pDevInsR3, PDMIBASE_2_PDMDRV(pDrv->pDrvBase), 0 /* fFlags */);
@@ -4653 +4656 @@
 
     if (RT_SUCCESS(rc))
-        rc = hdaAttachInternal(pThis, uLUN, 0 /* fFlags */, NULL /* ppDrv */);
+        rc = hdaR3AttachInternal(pThis, uLUN, 0 /* fFlags */, NULL /* ppDrv */);
 
     LogFunc(("pThis=%p, uLUN=%u, pszDriver=%s, rc=%Rrc\n", pThis, uLUN, pszDriver, rc));
@@ -4666 +4669 @@
  * @interface_method_impl{PDMDEVREG,pfnReset}
  */
-static DECLCALLBACK(void) hdaReset(PPDMDEVINS pDevIns)
+static DECLCALLBACK(void) hdaR3Reset(PPDMDEVINS pDevIns)
 {
     PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
@@ -4676 +4679 @@
      /*
      * 18.2.6,7 defines that values of this registers might be cleared on power on/reset
-     * hdaReset shouldn't affects these registers.
+     * hdaR3Reset shouldn't affects these registers.
      */
     HDA_REG(pThis, WAKEEN)  = 0x0;
 
-    hdaGCTLReset(pThis);
+    hdaR3GCTLReset(pThis);
 
     /* Indicate that HDA is not in reset. The firmware is supposed to (un)reset HDA,
@@ -4694 +4697 @@
  * @interface_method_impl{PDMDEVREG,pfnRelocate}
  */
-static DECLCALLBACK(void) hdaRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
+static DECLCALLBACK(void) hdaR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
 {
     NOREF(offDelta);
@@ -4705 +4708 @@
  * @interface_method_impl{PDMDEVREG,pfnDestruct}
  */
-static DECLCALLBACK(int) hdaDestruct(PPDMDEVINS pDevIns)
+static DECLCALLBACK(int) hdaR3Destruct(PPDMDEVINS pDevIns)
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
@@ -4735 +4738 @@
 
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
-        hdaStreamDestroy(&pThis->aStreams[i]);
+        hdaR3StreamDestroy(&pThis->aStreams[i]);
 
     DEVHDA_UNLOCK(pThis);
@@ -4745 +4748 @@
  * @interface_method_impl{PDMDEVREG,pfnConstruct}
  */
-static DECLCALLBACK(int) hdaConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
+static DECLCALLBACK(int) hdaR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
 {
     RT_NOREF(iInstance);
@@ -4839 +4842 @@
     pThis->pDevInsRC                = PDMDEVINS_2_RCPTR(pDevIns);
     /* IBase */
-    pThis->IBase.pfnQueryInterface  = hdaQueryInterface;
+    pThis->IBase.pfnQueryInterface  = hdaR3QueryInterface;
 
     /* PCI Device */
@@ -4925 +4928 @@
         return rc;
 
-    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x4000, PCI_ADDRESS_SPACE_MEM, hdaPciIoRegionMap);
+    rc = PDMDevHlpPCIIORegionRegister(pDevIns, 0, 0x4000, PCI_ADDRESS_SPACE_MEM, hdaR3PciIoRegionMap);
     if (RT_FAILURE(rc))
         return rc;
@@ -4943 +4946 @@
 #endif
 
-    rc = PDMDevHlpSSMRegister(pDevIns, HDA_SSM_VERSION, sizeof(*pThis), hdaSaveExec, hdaLoadExec);
+    rc = PDMDevHlpSSMRegister(pDevIns, HDA_SSM_VERSION, sizeof(*pThis), hdaR3SaveExec, hdaR3LoadExec);
     if (RT_FAILURE(rc))
         return rc;
@@ -4955 +4958 @@
     {
         LogFunc(("Trying to attach driver for LUN #%RU32 ...\n", uLUN));
-        rc = hdaAttachInternal(pThis, uLUN, 0 /* fFlags */, NULL /* ppDrv */);
+        rc = hdaR3AttachInternal(pThis, uLUN, 0 /* fFlags */, NULL /* ppDrv */);
         if (RT_FAILURE(rc))
         {
@@ -4962 +4965 @@
             else if (rc == VERR_AUDIO_BACKEND_INIT_FAILED)
             {
-                hdaReattachInternal(pThis, NULL /* pDrv */, uLUN, "NullAudio");
+                hdaR3ReattachInternal(pThis, NULL /* pDrv */, uLUN, "NullAudio");
                 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
                     N_("Host audio backend initialization has failed. Selecting the NULL audio backend "
@@ -5042 +5045 @@
         {
             /* Set codec callbacks to this controller. */
-            pThis->pCodec->pfnCbMixerAddStream    = hdaMixerAddStream;
-            pThis->pCodec->pfnCbMixerRemoveStream = hdaMixerRemoveStream;
-            pThis->pCodec->pfnCbMixerControl      = hdaMixerControl;
-            pThis->pCodec->pfnCbMixerSetVolume    = hdaMixerSetVolume;
+            pThis->pCodec->pfnCbMixerAddStream    = hdaR3MixerAddStream;
+            pThis->pCodec->pfnCbMixerRemoveStream = hdaR3MixerRemoveStream;
+            pThis->pCodec->pfnCbMixerControl      = hdaR3MixerControl;
+            pThis->pCodec->pfnCbMixerSetVolume    = hdaR3MixerSetVolume;
 
             pThis->pCodec->pHDAState = pThis; /* Assign HDA controller state to codec. */
@@ -5079 +5082 @@
             RTStrPrintf2(szTimer, sizeof(szTimer), "HDA SD%RU8", i);
 
-            rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaTimer, &pThis->aStreams[i],
+            rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, &pThis->aStreams[i],
                                         TMTIMER_FLAGS_NO_CRIT_SECT, szTimer, &pThis->pTimer[i]);
             AssertRCReturn(rc, rc);
@@ -5088 +5091 @@
             AssertRCReturn(rc, rc);
 
-            rc = hdaStreamCreate(&pThis->aStreams[i], pThis, i /* u8SD */);
+            rc = hdaR3StreamCreate(&pThis->aStreams[i], pThis, i /* u8SD */);
             AssertRC(rc);
         }
@@ -5126 +5129 @@
                 LogRel(("HDA: Falling back to NULL backend (no sound audible)\n"));
 
-                hdaReset(pDevIns);
-                hdaReattachInternal(pThis, pDrv, pDrv->uLUN, "NullAudio");
+                hdaR3Reset(pDevIns);
+                hdaR3ReattachInternal(pThis, pDrv, pDrv->uLUN, "NullAudio");
 
                 PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
@@ -5209 +5212 @@
     if (RT_SUCCESS(rc))
     {
-        hdaReset(pDevIns);
+        hdaR3Reset(pDevIns);
 
         /*
          * Debug and string formatter types.
          */
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hda",         "HDA info. (hda [register case-insensitive])",     hdaDbgInfo);
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hdabdle",     "HDA stream BDLE info. (hdabdle [stream number])", hdaDbgInfoBDLE);
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hdastream",   "HDA stream info. (hdastream [stream number])",    hdaDbgInfoStream);
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hdcnodes",    "HDA codec nodes.",                                hdaDbgInfoCodecNodes);
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hdcselector", "HDA codec's selector states [node number].",      hdaDbgInfoCodecSelector);
-        PDMDevHlpDBGFInfoRegister(pDevIns, "hdamixer",    "HDA mixer state.",                                hdaDbgInfoMixer);
-
-        rc = RTStrFormatTypeRegister("bdle",    hdaDbgFmtBDLE,    NULL);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hda",         "HDA info. (hda [register case-insensitive])",     hdaR3DbgInfo);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hdabdle",     "HDA stream BDLE info. (hdabdle [stream number])", hdaR3DbgInfoBDLE);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hdastream",   "HDA stream info. (hdastream [stream number])",    hdaR3DbgInfoStream);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hdcnodes",    "HDA codec nodes.",                                hdaR3DbgInfoCodecNodes);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hdcselector", "HDA codec's selector states [node number].",      hdaR3DbgInfoCodecSelector);
+        PDMDevHlpDBGFInfoRegister(pDevIns, "hdamixer",    "HDA mixer state.",                                hdaR3DbgInfoMixer);
+
+        rc = RTStrFormatTypeRegister("bdle",    hdaR3StrFmtBDLE,    NULL);
         AssertRC(rc);
-        rc = RTStrFormatTypeRegister("sdctl",   hdaDbgFmtSDCTL,   NULL);
+        rc = RTStrFormatTypeRegister("sdctl",   hdaR3StrFmtSDCTL,   NULL);
         AssertRC(rc);
-        rc = RTStrFormatTypeRegister("sdsts",   hdaDbgFmtSDSTS,   NULL);
+        rc = RTStrFormatTypeRegister("sdsts",   hdaR3StrFmtSDSTS,   NULL);
         AssertRC(rc);
-        rc = RTStrFormatTypeRegister("sdfifos", hdaDbgFmtSDFIFOS, NULL);
+        rc = RTStrFormatTypeRegister("sdfifos", hdaR3StrFmtSDFIFOS, NULL);
         AssertRC(rc);
-        rc = RTStrFormatTypeRegister("sdfifow", hdaDbgFmtSDFIFOW, NULL);
+        rc = RTStrFormatTypeRegister("sdfifow", hdaR3StrFmtSDFIFOW, NULL);
         AssertRC(rc);
 
@@ -5285 +5288 @@
          * Register statistics.
          */
-        PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTimer,            STAMTYPE_PROFILE, "/Devices/HDA/Timer",             STAMUNIT_TICKS_PER_CALL, "Profiling hdaTimer.");
+        PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTimer,            STAMTYPE_PROFILE, "/Devices/HDA/Timer",             STAMUNIT_TICKS_PER_CALL, "Profiling hdaR3Timer.");
         PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIn,               STAMTYPE_PROFILE, "/Devices/HDA/Input",             STAMUNIT_TICKS_PER_CALL, "Profiling input.");
         PDMDevHlpSTAMRegister(pDevIns, &pThis->StatOut,              STAMTYPE_PROFILE, "/Devices/HDA/Output",            STAMUNIT_TICKS_PER_CALL, "Profiling output.");
@@ -5321 +5324 @@
     sizeof(HDASTATE),
     /* pfnConstruct */
-    hdaConstruct,
+    hdaR3Construct,
     /* pfnDestruct */
-    hdaDestruct,
+    hdaR3Destruct,
     /* pfnRelocate */
-    hdaRelocate,
+    hdaR3Relocate,
     /* pfnMemSetup */
     NULL,
@@ -5331 +5334 @@
     NULL,
     /* pfnReset */
-    hdaReset,
+    hdaR3Reset,
     /* pfnSuspend */
     NULL,
@@ -5337 +5340 @@
     NULL,
     /* pfnAttach */
-    hdaAttach,
+    hdaR3Attach,
     /* pfnDetach */
-    hdaDetach,
+    hdaR3Detach,
     /* pfnQueryInterface. */
     NULL,
@@ -5345 +5348 @@
     NULL,
     /* pfnPowerOff */
-    hdaPowerOff,
+    hdaR3PowerOff,
     /* pfnSoftReset */
     NULL,

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

@@ -113 +113 @@
  * @param   fForce              Whether to force setting the wall clock value or not.
  */
-bool hdaWalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce)
-{
-    const bool     fFrontPassed       = hdaStreamPeriodHasPassedAbsWalClk (&hdaGetStreamFromSink(pThis, &pThis->SinkFront)->State.Period,
+bool hdaR3WalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce)
+{
+    const bool     fFrontPassed       = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkFront)->State.Period,
                                                                            u64WalClk);
-    const uint64_t u64FrontAbsWalClk  = hdaStreamPeriodGetAbsElapsedWalClk(&hdaGetStreamFromSink(pThis, &pThis->SinkFront)->State.Period);
+    const uint64_t u64FrontAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkFront)->State.Period);
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
 #  error "Implement me!"
 # endif
 
-    const bool     fLineInPassed      = hdaStreamPeriodHasPassedAbsWalClk (&hdaGetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period, u64WalClk);
-    const uint64_t u64LineInAbsWalClk = hdaStreamPeriodGetAbsElapsedWalClk(&hdaGetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period);
+    const bool     fLineInPassed      = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period, u64WalClk);
+    const uint64_t u64LineInAbsWalClk = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period);
 # ifdef VBOX_WITH_HDA_MIC_IN
-    const bool     fMicInPassed       = hdaStreamPeriodHasPassedAbsWalClk (&hdaGetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period,  u64WalClk);
-    const uint64_t u64MicInAbsWalClk  = hdaStreamPeriodGetAbsElapsedWalClk(&hdaGetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period);
+    const bool     fMicInPassed       = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period,  u64WalClk);
+    const uint64_t u64MicInAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period);
 # endif
 
@@ -196 +196 @@
  *                              NULL if not found / handled.
  */
-PHDAMIXERSINK hdaGetDefaultSink(PHDASTATE pThis, uint8_t uSD)
+PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATE pThis, uint8_t uSD)
 {
     if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
@@ -229 +229 @@
 }
 
-#endif /* IN_RING */
+#endif /* IN_RING3 */
 
 /**
@@ -279 +279 @@
  * @return  Pointer to HDA stream, or NULL if none found.
  */
-PHDASTREAM hdaGetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
+PHDASTREAM hdaR3GetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
 {
     AssertPtrReturn(pThis, NULL);
@@ -298 +298 @@
  * @param   pcbRead             Returns read bytes from DMA. Optional.
  */
-int hdaDMARead(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
+int hdaR3DMARead(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
@@ -383 +383 @@
  * @param   pcbWritten          Returns written bytes on success. Optional.
  */
-int hdaDMAWrite(PHDASTATE pThis, PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+int hdaR3DMAWrite(PHDASTATE pThis, PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
@@ -477 +477 @@
 }
 
+#ifdef IN_RING3
+
 /**
  * Converts an HDA stream's SDFMT register into a given PCM properties structure.
@@ -484 +486 @@
  * @param   pProps              PCM properties structure to hold converted result on success.
  */
-int hdaSDFMTToPCMProps(uint32_t u32SDFMT, PPDMAUDIOPCMPROPS pProps)
+int hdaR3SDFMTToPCMProps(uint32_t u32SDFMT, PPDMAUDIOPCMPROPS pProps)
 {
     AssertPtrReturn(pProps, VERR_INVALID_POINTER);
 
-#define EXTRACT_VALUE(v, mask, shift) ((v & ((mask) << (shift))) >> (shift))
+# define EXTRACT_VALUE(v, mask, shift) ((v & ((mask) << (shift))) >> (shift))
 
     int rc = VINF_SUCCESS;
@@ -556 +558 @@
     }
 
-#undef EXTRACT_VALUE
+# undef EXTRACT_VALUE
     return rc;
 }
 
-#ifdef IN_RING3
-
 # ifdef LOG_ENABLED
-void hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE)
+void hdaR3BDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE)
 {
     LogFlowFunc(("BDLEs @ 0x%x (%RU16):\n", u64BDLBase, cBDLE));
@@ -607 +607 @@
  * @param   u16Entry                BDLE entry to fetch.
  */
-int hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry)
+int hdaR3BDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
@@ -642 +642 @@
  * @param   pBDLE               BDLE to retrieve status for.
  */
-bool hdaBDLEIsComplete(PHDABDLE pBDLE)
+bool hdaR3BDLEIsComplete(PHDABDLE pBDLE)
 {
     bool fIsComplete = false;
@@ -664 +664 @@
  * @param   pBDLE               BDLE to retrieve status for.
  */
-bool hdaBDLENeedsInterrupt(PHDABDLE pBDLE)
+bool hdaR3BDLENeedsInterrupt(PHDABDLE pBDLE)
 {
     return (pBDLE->Desc.fFlags & HDA_BDLE_FLAG_IOC);
@@ -687 +687 @@
  *          Forcing a new expiration time will override the above mechanism.
  */
-bool hdaTimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t tsExpire, bool fForce)
+bool hdaR3TimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t tsExpire, bool fForce)
 {
     AssertPtr(pThis);
@@ -696 +696 @@
     if (!fForce)
     {
-        if (hdaStreamTransferIsScheduled(pStream))
-            tsExpireMin = RT_MIN(tsExpireMin, hdaStreamTransferGetNext(pStream));
+        if (hdaR3StreamTransferIsScheduled(pStream))
+            tsExpireMin = RT_MIN(tsExpireMin, hdaR3StreamTransferGetNext(pStream));
     }
 

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

@@ -76 +76 @@
 #define HDA_NUM_GENERAL_REGS        34
 /** Number of total registers in the HDA's register map. */
-#define HDA_NUM_REGS                                       (HDA_NUM_GENERAL_REGS + (HDA_MAX_STREAMS * 10 /* Each stream descriptor has 10 registers */))
+#define HDA_NUM_REGS                (HDA_NUM_GENERAL_REGS + (HDA_MAX_STREAMS * 10 /* Each stream descriptor has 10 registers */))
 /** Total number of stream tags (channels). Index 0 is reserved / invalid. */
 #define HDA_MAX_TAGS                16
@@ -517 +517 @@
 
 
-/*********************************************************************************************************************************
-*   Prototypes                                                                                                                 *
-*********************************************************************************************************************************/
 
 /** The HDA controller. */
@@ -580 +577 @@
  * @{
  */
-PHDAMIXERSINK hdaGetDefaultSink(PHDASTATE pThis, uint8_t uSD);
+#ifdef IN_RING3
+PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATE pThis, uint8_t uSD);
+#endif
 PDMAUDIODIR   hdaGetDirFromSD(uint8_t uSD);
 PHDASTREAM    hdaGetStreamFromSD(PHDASTATE pThis, uint8_t uSD);
-PHDASTREAM    hdaGetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink);
+#ifdef IN_RING3
+PHDASTREAM    hdaR3GetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink);
+#endif
 /** @} */
 
@@ -601 +602 @@
 uint64_t      hdaWalClkGetCurrent(PHDASTATE pThis);
 #ifdef IN_RING3
-bool          hdaWalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce);
+bool          hdaR3WalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce);
 #endif
 /** @} */
@@ -608 +609 @@
  * @{
  */
-int           hdaDMARead(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
-int           hdaDMAWrite(PHDASTATE pThis, PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
+#ifdef IN_RING3
+int           hdaR3DMARead(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
+int           hdaR3DMAWrite(PHDASTATE pThis, PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
+#endif
 /** @} */
 
@@ -617 +620 @@
 uint32_t      hdaGetINTSTS(PHDASTATE pThis);
 #ifdef IN_RING3
-int           hdaSDFMTToPCMProps(uint32_t u32SDFMT, PPDMAUDIOPCMPROPS pProps);
+int           hdaR3SDFMTToPCMProps(uint32_t u32SDFMT, PPDMAUDIOPCMPROPS pProps);
 #endif /* IN_RING3 */
 /** @} */
@@ -626 +629 @@
 #ifdef IN_RING3
 # ifdef LOG_ENABLED
-void          hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE);
+void          hdaR3BDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE);
 # endif
-int           hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
-bool          hdaBDLEIsComplete(PHDABDLE pBDLE);
-bool          hdaBDLENeedsInterrupt(PHDABDLE pBDLE);
+int           hdaR3BDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
+bool          hdaR3BDLEIsComplete(PHDABDLE pBDLE);
+bool          hdaR3BDLENeedsInterrupt(PHDABDLE pBDLE);
 #endif /* IN_RING3 */
 /** @} */
@@ -638 +641 @@
  */
 #ifdef IN_RING3
-bool          hdaTimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t u64Expire, bool fForce);
+bool          hdaR3TimerSet(PHDASTATE pThis, PHDASTREAM pStream, uint64_t u64Expire, bool fForce);
 #endif /* IN_RING3 */
 /** @} */

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

@@ -45 +45 @@
  * @param   u8SD                Stream descriptor number to assign.
  */
-int hdaStreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD)
+int hdaR3StreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD)
 {
     RT_NOREF(pThis);
@@ -68 +68 @@
     AssertRCReturn(rc, rc);
 
-    rc = hdaStreamPeriodCreate(&pStream->State.Period);
+    rc = hdaR3StreamPeriodCreate(&pStream->State.Period);
     AssertRCReturn(rc, rc);
 
@@ -119 +119 @@
  * @param   pStream             HDA stream to destroy.
  */
-void hdaStreamDestroy(PHDASTREAM pStream)
+void hdaR3StreamDestroy(PHDASTREAM pStream)
 {
     AssertPtrReturnVoid(pStream);
@@ -125 +125 @@
     LogFlowFunc(("[SD%RU8]: Destroying ...\n", pStream->u8SD));
 
-    hdaStreamMapDestroy(&pStream->State.Mapping);
+    hdaR3StreamMapDestroy(&pStream->State.Mapping);
 
     int rc2;
 
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    rc2 = hdaStreamAsyncIODestroy(pStream);
+    rc2 = hdaR3StreamAsyncIODestroy(pStream);
     AssertRC(rc2);
 #endif
@@ -146 +146 @@
     }
 
-    hdaStreamPeriodDestroy(&pStream->State.Period);
+    hdaR3StreamPeriodDestroy(&pStream->State.Period);
 
 #ifdef DEBUG
@@ -175 +175 @@
  * @param   uSD                 SD (stream descriptor) number to assign the HDA stream to.
  */
-int hdaStreamInit(PHDASTREAM pStream, uint8_t uSD)
+int hdaR3StreamInit(PHDASTREAM pStream, uint8_t uSD)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -191 +191 @@
     PPDMAUDIOSTREAMCFG pCfg = &pStream->State.Cfg;
 
-    int rc = hdaSDFMTToPCMProps(HDA_STREAM_REG(pThis, FMT, uSD), &pCfg->Props);
+    int rc = hdaR3SDFMTToPCMProps(HDA_STREAM_REG(pThis, FMT, uSD), &pCfg->Props);
     if (RT_FAILURE(rc))
     {
@@ -246 +246 @@
      * number of channels in a single audio stream.
      */
-    rc = hdaStreamMapInit(&pStream->State.Mapping, &pCfg->Props);
+    rc = hdaR3StreamMapInit(&pStream->State.Mapping, &pCfg->Props);
     AssertRCReturn(rc, rc);
 
@@ -284 +284 @@
             RT_ZERO(BDLE);
 
-            int rc2 = hdaBDLEFetch(pThis, &BDLE, pStream->u64BDLBase, 0 /* Entry */);
+            int rc2 = hdaR3BDLEFetch(pThis, &BDLE, pStream->u64BDLBase, 0 /* Entry */);
             AssertRC(rc2);
 
@@ -299 +299 @@
             if (   !pThis->cPosAdjustFrames
             /* Position adjustmenet buffer *must* have the IOC bit set! */
-                && hdaBDLENeedsInterrupt(&BDLE))
+                && hdaR3BDLENeedsInterrupt(&BDLE))
             {
                 /** @todo Implement / use a (dynamic) table once this gets more complicated. */
@@ -387 +387 @@
 
         /* Make sure to also update the stream's DMA counter (based on its current LPIB value). */
-        hdaStreamSetPosition(pStream, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD));
+        hdaR3StreamSetPosition(pStream, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD));
 
 #ifdef LOG_ENABLED
-        hdaBDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+        hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
 #endif
     }
@@ -407 +407 @@
  * @param   uSD                 Stream descriptor (SD) number to use for this stream.
  */
-void hdaStreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD)
+void hdaR3StreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD)
 {
     AssertPtrReturnVoid(pThis);
@@ -444 +444 @@
 
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
-    hdaStreamUnregisterDMAHandlers(pThis, pStream);
+    hdaR3StreamUnregisterDMAHandlers(pThis, pStream);
 #endif
 
     /* Assign the default mixer sink to the stream. */
-    pStream->pMixSink             = hdaGetDefaultSink(pThis, uSD);
+    pStream->pMixSink             = hdaR3GetDefaultSink(pThis, uSD);
 
     pStream->State.tsTransferLast = 0;
@@ -460 +460 @@
 
     /* Reset stream map. */
-    hdaStreamMapReset(&pStream->State.Mapping);
+    hdaR3StreamMapReset(&pStream->State.Mapping);
 
     /* (Re-)initialize the stream with current values. */
-    int rc2 = hdaStreamInit(pStream, uSD);
+    int rc2 = hdaR3StreamInit(pStream, uSD);
     AssertRC(rc2);
 
     /* Reset the stream's period. */
-    hdaStreamPeriodReset(&pStream->State.Period);
+    hdaR3StreamPeriodReset(&pStream->State.Period);
 
 #ifdef DEBUG
@@ -496 +496 @@
  * @param   fEnable             Whether to enable or disble the stream.
  */
-int hdaStreamEnable(PHDASTREAM pStream, bool fEnable)
+int hdaR3StreamEnable(PHDASTREAM pStream, bool fEnable)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -545 +545 @@
 }
 
-uint32_t hdaStreamGetPosition(PHDASTATE pThis, PHDASTREAM pStream)
+uint32_t hdaR3StreamGetPosition(PHDASTATE pThis, PHDASTREAM pStream)
 {
     return HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
@@ -557 +557 @@
  * @param   u32LPIB             Absolute position (in bytes) to set current read / write position to.
  */
-void hdaStreamSetPosition(PHDASTREAM pStream, uint32_t u32LPIB)
+void hdaR3StreamSetPosition(PHDASTREAM pStream, uint32_t u32LPIB)
 {
     AssertPtrReturnVoid(pStream);
@@ -583 +583 @@
  * @param   pStream             HDA stream to retrieve size for.
  */
-uint32_t hdaStreamGetUsed(PHDASTREAM pStream)
+uint32_t hdaR3StreamGetUsed(PHDASTREAM pStream)
 {
     AssertPtrReturn(pStream, 0);
@@ -599 +599 @@
  * @param   pStream             HDA stream to retrieve size for.
  */
-uint32_t hdaStreamGetFree(PHDASTREAM pStream)
+uint32_t hdaR3StreamGetFree(PHDASTREAM pStream)
 {
     AssertPtrReturn(pStream, 0);
@@ -617 +617 @@
  * @param   pStream             HDA stream to retrieve schedule status for.
  */
-bool hdaStreamTransferIsScheduled(PHDASTREAM pStream)
+bool hdaR3StreamTransferIsScheduled(PHDASTREAM pStream)
 {
     if (pStream)
@@ -649 +649 @@
  * @param   pStream             HDA stream to retrieve timestamp for.
  */
-uint64_t hdaStreamTransferGetNext(PHDASTREAM pStream)
+uint64_t hdaR3StreamTransferGetNext(PHDASTREAM pStream)
 {
     return pStream->State.tsTransferNext;
@@ -664 +664 @@
  * @param   pcbWritten          Number of bytes written. Optional.
  */
-int hdaStreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+int hdaR3StreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -731 +731 @@
  * @param   pcbRead             Number of bytes read. Optional.
  */
-int hdaStreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead)
+int hdaR3StreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
@@ -806 +806 @@
  * @param   cbToProcessMax      How much data (in bytes) to process as maximum.
  */
-int hdaStreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax)
+int hdaR3StreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax)
 {
     AssertPtrReturn(pStream, VERR_INVALID_POINTER);
 
-    hdaStreamLock(pStream);
+    hdaR3StreamLock(pStream);
 
     PHDASTATE pThis = pStream->pHDAState;
@@ -816 +816 @@
 
     PHDASTREAMPERIOD pPeriod = &pStream->State.Period;
-    if (!hdaStreamPeriodLock(pPeriod))
+    if (!hdaR3StreamPeriodLock(pPeriod))
         return VERR_ACCESS_DENIED;
 
@@ -835 +835 @@
     if (!fProceed)
     {
-        hdaStreamPeriodUnlock(pPeriod);
-        hdaStreamUnlock(pStream);
+        hdaR3StreamPeriodUnlock(pPeriod);
+        hdaR3StreamUnlock(pStream);
         return VINF_SUCCESS;
     }
@@ -866 +866 @@
     /* Fetch first / next BDL entry. */
     PHDABDLE pBDLE = &pStream->State.BDLE;
-    if (hdaBDLEIsComplete(pBDLE))
-    {
-        rc = hdaBDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
+    if (hdaR3BDLEIsComplete(pBDLE))
+    {
+        rc = hdaR3BDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
         AssertRC(rc);
     }
@@ -956 +956 @@
             }
 
-            rc = hdaDMAWrite(pThis, pStream, abChunk, cbDMAWritten, &cbDMA /* pcbWritten */);
+            rc = hdaR3DMAWrite(pThis, pStream, abChunk, cbDMAWritten, &cbDMA /* pcbWritten */);
             if (RT_FAILURE(rc))
                 LogRel(("HDA: Writing to stream #%RU8 DMA failed with %Rrc\n", pStream->u8SD, rc));
@@ -966 +966 @@
             STAM_PROFILE_START(&pThis->StatOut, a);
 
-            rc = hdaDMARead(pThis, pStream, abChunk, cbChunk, &cbDMA /* pcbRead */);
+            rc = hdaR3DMARead(pThis, pStream, abChunk, cbChunk, &cbDMA /* pcbRead */);
             if (RT_SUCCESS(rc))
             {
@@ -999 +999 @@
                 else
                 {
-                    /**
+                    /*
                      * The following code extracts the required audio stream (channel) data
                      * of non-interleaved *and* interleaved audio streams.
@@ -1010 +1010 @@
                      * and just discard the other channel's data.
                      *
-                     * @todo Optimize this stuff -- copying only one frame a time is expensive.
                      */
+                    /** @todo Optimize this stuff -- copying only one frame a time is expensive. */
                     uint32_t cbDMARead = pStream->State.cbDMALeft ? pStream->State.cbFrameSize - pStream->State.cbDMALeft : 0;
                     uint32_t cbDMALeft = RT_MIN(cbDMA, (uint32_t)RTCircBufFree(pCircBuf));
@@ -1070 +1070 @@
             }
 
-            /**
+            /*
              * Update the stream's current position.
              * Do this as accurate and close to the actual data transfer as possible.
              * All guetsts rely on this, depending on the mechanism they use (LPIB register or DMA counters).
              */
-            uint32_t cbStreamPos = hdaStreamGetPosition(pThis, pStream);
+            uint32_t cbStreamPos = hdaR3StreamGetPosition(pThis, pStream);
             if (cbStreamPos == pStream->u32CBL)
                 cbStreamPos = 0;
 
-            hdaStreamSetPosition(pStream, cbStreamPos + cbDMA);
-        }
-
-        if (hdaBDLEIsComplete(pBDLE))
+            hdaR3StreamSetPosition(pStream, cbStreamPos + cbDMA);
+        }
+
+        if (hdaR3BDLEIsComplete(pBDLE))
         {
             Log3Func(("[SD%RU8] Complete: %R[bdle]\n", pStream->u8SD, pBDLE));
 
                 /* Does the current BDLE require an interrupt to be sent? */
-            if (   hdaBDLENeedsInterrupt(pBDLE)
+            if (   hdaR3BDLENeedsInterrupt(pBDLE)
                 /* Are we done doing the position adjustment?
                  * It can happen that a BDLE which is handled while doing the
@@ -1116 +1116 @@
 
             /* Fetch the next BDLE entry. */
-            hdaBDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
+            hdaR3BDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
         }
 
@@ -1137 +1137 @@
     if (pStream->State.cPosAdjustFramesLeft == 0)
     {
-        hdaStreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStream->State.cbFrameSize, hdaStreamPeriodGetRemainingFrames(pPeriod)));
+        hdaR3StreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStream->State.cbFrameSize,
+                                             hdaR3StreamPeriodGetRemainingFrames(pPeriod)));
 
         pStream->State.cbTransferProcessed += cbProcessed;
@@ -1152 +1153 @@
     if (fTransferComplete)
     {
-        /**
+        /*
          * Try updating the wall clock.
          *
@@ -1164 +1165 @@
          *         sound output. Running VLC on the guest will tell!
          */
-        const bool fWalClkSet = hdaWalClkSet(pThis,
-                                               hdaWalClkGetCurrent(pThis)
-                                             + hdaStreamPeriodFramesToWalClk(pPeriod, pStream->State.cbTransferProcessed / pStream->State.cbFrameSize),
-                                             false /* fForce */);
+        const bool fWalClkSet = hdaR3WalClkSet(pThis,
+                                                 hdaWalClkGetCurrent(pThis)
+                                               + hdaR3StreamPeriodFramesToWalClk(pPeriod,
+                                                                                   pStream->State.cbTransferProcessed
+                                                                                 / pStream->State.cbFrameSize),
+                                               false /* fForce */);
         RT_NOREF(fWalClkSet);
     }
@@ -1176 +1179 @@
         Log3Func(("[SD%RU8] Scheduling interrupt\n", pStream->u8SD));
 
-        /**
+        /*
          * Set the stream's BCIS bit.
          *
@@ -1211 +1214 @@
         tsTransferNext = tsNow + (cbTransferNext * pStream->State.cTicksPerByte);
 
-        /**
+        /*
          * If the current transfer is complete, reset our counter.
          *
@@ -1230 +1233 @@
 
         LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-        hdaTimerSet(pStream->pHDAState, pStream, tsTransferNext, false /* fForce */);
+        hdaR3TimerSet(pStream->pHDAState, pStream, tsTransferNext, false /* fForce */);
 
         TMTimerLock(pStream->pTimer, VINF_SUCCESS);
@@ -1246 +1249 @@
               pStream->u8SD, tsNow, tsTransferNext, tsTransferNext - tsNow));
 
-    hdaStreamPeriodUnlock(pPeriod);
-    hdaStreamUnlock(pStream);
+    hdaR3StreamPeriodUnlock(pPeriod);
+    hdaR3StreamUnlock(pStream);
 
     return VINF_SUCCESS;
@@ -1262 +1265 @@
  *                              context or an asynchronous I/O stream thread (if supported).
  */
-void hdaStreamUpdate(PHDASTREAM pStream, bool fInTimer)
+void hdaR3StreamUpdate(PHDASTREAM pStream, bool fInTimer)
 {
     if (!pStream)
@@ -1282 +1285 @@
     {
         /* Is the HDA stream ready to be written (guest output data) to? If so, by how much? */
-        const uint32_t cbFree = hdaStreamGetFree(pStream);
+        const uint32_t cbFree = hdaR3StreamGetFree(pStream);
 
         if (   fInTimer
@@ -1290 +1293 @@
 
             /* Do the DMA transfer. */
-            rc2 = hdaStreamTransfer(pStream, cbFree);
+            rc2 = hdaR3StreamTransfer(pStream, cbFree);
             AssertRC(rc2);
         }
 
         /* How much (guest output) data is available at the moment for the HDA stream? */
-        uint32_t cbUsed = hdaStreamGetUsed(pStream);
+        uint32_t cbUsed = hdaR3StreamGetUsed(pStream);
 
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
@@ -1301 +1304 @@
             && cbUsed)
         {
-            rc2 = hdaStreamAsyncIONotify(pStream);
+            rc2 = hdaR3StreamAsyncIONotify(pStream);
             AssertRC(rc2);
         }
@@ -1317 +1320 @@
             {
                 /* Read (guest output) data and write it to the stream's sink. */
-                rc2 = hdaStreamRead(pStream, cbUsed, NULL /* pcbRead */);
+                rc2 = hdaR3StreamRead(pStream, cbUsed, NULL /* pcbRead */);
                 AssertRC(rc2);
             }
@@ -1343 +1346 @@
 
             /* How much (guest input) data is available for writing at the moment for the HDA stream? */
-            const uint32_t cbFree = hdaStreamGetFree(pStream);
+            const uint32_t cbFree = hdaR3StreamGetFree(pStream);
 
             Log3Func(("[SD%RU8] cbReadable=%RU32, cbFree=%RU32\n", pStream->u8SD, cbReadable, cbFree));
@@ -1370 +1373 @@
                     /* Write (guest input) data to the stream which was read from stream's sink before. */
                     uint32_t cbWritten;
-                    rc2 = hdaStreamWrite(pStream, abFIFO, cbRead, &cbWritten);
+                    rc2 = hdaR3StreamWrite(pStream, abFIFO, cbRead, &cbWritten);
                     AssertRCBreak(rc2);
 
@@ -1392 +1395 @@
                 if (cbReadable)
                 {
-                    rc2 = hdaStreamWrite(pStream, NULL /* Silence */, cbReadable, NULL /* pcbWritten */);
+                    rc2 = hdaR3StreamWrite(pStream, NULL /* Silence */, cbReadable, NULL /* pcbWritten */);
                     AssertRC(rc2);
                 }
@@ -1409 +1412 @@
             if (tsNow - s_lasti >= 10) /** @todo Fix this properly. */
             {
-                rc2 = hdaStreamAsyncIONotify(pStream);
+                rc2 = hdaR3StreamAsyncIONotify(pStream);
                 AssertRC(rc2);
 
@@ -1415 +1418 @@
             }
 
-            const uint32_t cbToTransfer = hdaStreamGetUsed(pStream);
+            const uint32_t cbToTransfer = hdaR3StreamGetUsed(pStream);
             if (cbToTransfer)
             {
-                rc2 = hdaStreamTransfer(pStream, cbToTransfer);
+                rc2 = hdaR3StreamTransfer(pStream, cbToTransfer);
                 AssertRC(rc2);
             }
@@ -1433 +1436 @@
  * @param   pStream             HDA stream to lock.
  */
-void hdaStreamLock(PHDASTREAM pStream)
+void hdaR3StreamLock(PHDASTREAM pStream)
 {
     AssertPtrReturnVoid(pStream);
@@ -1446 +1449 @@
  * @param   pStream             HDA stream to unlock.
  */
-void hdaStreamUnlock(PHDASTREAM pStream)
+void hdaR3StreamUnlock(PHDASTREAM pStream)
 {
     AssertPtrReturnVoid(pStream);
@@ -1461 +1464 @@
  * @param   u32LPIB             New LPIB (position) value to set.
  */
-uint32_t hdaStreamUpdateLPIB(PHDASTREAM pStream, uint32_t u32LPIB)
+uint32_t hdaR3StreamUpdateLPIB(PHDASTREAM pStream, uint32_t u32LPIB)
 {
     AssertPtrReturn(pStream, 0);
@@ -1497 +1500 @@
  * @param   pStream             HDA stream to register BDLE access handlers for.
  */
-bool hdaStreamRegisterDMAHandlers(PHDASTREAM pStream)
+bool hdaR3StreamRegisterDMAHandlers(PHDASTREAM pStream)
 {
     /* At least LVI and the BDL base must be set. */
@@ -1506 +1509 @@
     }
 
-    hdaStreamUnregisterDMAHandlers(pStream);
+    hdaR3StreamUnregisterDMAHandlers(pStream);
 
     LogFunc(("Registering ...\n"));
@@ -1527 +1530 @@
     {
         HDABDLE BDLE;
-        rc = hdaBDLEFetch(pThis, &BDLE, pStream->u64BDLBase, i /* Index */);
+        rc = hdaR3BDLEFetch(pThis, &BDLE, pStream->u64BDLBase, i /* Index */);
         if (RT_FAILURE(rc))
             break;
@@ -1634 +1637 @@
  * @param   pStream             HDA stream to unregister BDLE access handlers for.
  */
-void hdaStreamUnregisterDMAHandlers(PHDASTREAM pStream)
+void hdaR3StreamUnregisterDMAHandlers(PHDASTREAM pStream)
 {
     LogFunc(("\n"));
@@ -1670 +1673 @@
  * @param   pvUser              User argument. Must be of type PHDASTREAMTHREADCTX.
  */
-DECLCALLBACK(int) hdaStreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser)
+DECLCALLBACK(int) hdaR3StreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser)
 {
     PHDASTREAMTHREADCTX pCtx = (PHDASTREAMTHREADCTX)pvUser;
@@ -1704 +1707 @@
             }
 
-            hdaStreamUpdate(pStream, false /* fInTimer */);
+            hdaR3StreamUpdate(pStream, false /* fInTimer */);
 
             int rc3 = RTCritSectLeave(&pAIO->CritSect);
@@ -1726 +1729 @@
  * @param   pStream             HDA audio stream to create the async I/O thread for.
  */
-int hdaStreamAsyncIOCreate(PHDASTREAM pStream)
+int hdaR3StreamAsyncIOCreate(PHDASTREAM pStream)
 {
     PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
@@ -1747 +1750 @@
                 RTStrPrintf2(szThreadName, sizeof(szThreadName), "hdaAIO%RU8", pStream->u8SD);
 
-                rc = RTThreadCreate(&pAIO->Thread, hdaStreamAsyncIOThread, &Ctx,
+                rc = RTThreadCreate(&pAIO->Thread, hdaR3StreamAsyncIOThread, &Ctx,
                                     0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, szThreadName);
                 if (RT_SUCCESS(rc))
@@ -1767 +1770 @@
  * @param   pStream             HDA audio stream to destroy the async I/O thread for.
  */
-int hdaStreamAsyncIODestroy(PHDASTREAM pStream)
+int hdaR3StreamAsyncIODestroy(PHDASTREAM pStream)
 {
     PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
@@ -1776 +1779 @@
     ASMAtomicWriteBool(&pAIO->fShutdown, true);
 
-    int rc = hdaStreamAsyncIONotify(pStream);
+    int rc = hdaR3StreamAsyncIONotify(pStream);
     AssertRC(rc);
 
@@ -1806 +1809 @@
  * @param   pStream             HDA stream to notify async I/O thread for.
  */
-int hdaStreamAsyncIONotify(PHDASTREAM pStream)
+int hdaR3StreamAsyncIONotify(PHDASTREAM pStream)
 {
     return RTSemEventSignal(pStream->State.AIO.Event);
@@ -1816 +1819 @@
  * @param   pStream             HDA stream to lock async I/O thread for.
  */
-void hdaStreamAsyncIOLock(PHDASTREAM pStream)
+void hdaR3StreamAsyncIOLock(PHDASTREAM pStream)
 {
     PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
@@ -1832 +1835 @@
  * @param   pStream             HDA stream to unlock async I/O thread for.
  */
-void hdaStreamAsyncIOUnlock(PHDASTREAM pStream)
+void hdaR3StreamAsyncIOUnlock(PHDASTREAM pStream)
 {
     PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
@@ -1851 +1854 @@
  * @remarks Does not do locking.
  */
-void hdaStreamAsyncIOEnable(PHDASTREAM pStream, bool fEnable)
+void hdaR3StreamAsyncIOEnable(PHDASTREAM pStream, bool fEnable)
 {
     PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;

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

@@ -243 +243 @@
  * @{
  */
-int               hdaStreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD);
-void              hdaStreamDestroy(PHDASTREAM pStream);
-int               hdaStreamInit(PHDASTREAM pStream, uint8_t uSD);
-void              hdaStreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD);
-int               hdaStreamEnable(PHDASTREAM pStream, bool fEnable);
-uint32_t          hdaStreamGetPosition(PHDASTATE pThis, PHDASTREAM pStream);
-void              hdaStreamSetPosition(PHDASTREAM pStream, uint32_t u32LPIB);
-uint32_t          hdaStreamGetFree(PHDASTREAM pStream);
-uint32_t          hdaStreamGetUsed(PHDASTREAM pStream);
-bool              hdaStreamTransferIsScheduled(PHDASTREAM pStream);
-uint64_t          hdaStreamTransferGetNext(PHDASTREAM pStream);
-int               hdaStreamTransfer(PHDASTREAM pStream, uint32_t cbToProcessMax);
-void              hdaStreamLock(PHDASTREAM pStream);
-void              hdaStreamUnlock(PHDASTREAM pStream);
-int               hdaStreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead);
-int               hdaStreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
-void              hdaStreamUpdate(PHDASTREAM pStream, bool fAsync);
+int               hdaR3StreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD);
+void              hdaR3StreamDestroy(PHDASTREAM pStream);
+int               hdaR3StreamInit(PHDASTREAM pStream, uint8_t uSD);
+void              hdaR3StreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD);
+int               hdaR3StreamEnable(PHDASTREAM pStream, bool fEnable);
+uint32_t          hdaR3StreamGetPosition(PHDASTATE pThis, PHDASTREAM pStream);
+void              hdaR3StreamSetPosition(PHDASTREAM pStream, uint32_t u32LPIB);
+uint32_t          hdaR3StreamGetFree(PHDASTREAM pStream);
+uint32_t          hdaR3StreamGetUsed(PHDASTREAM pStream);
+bool              hdaR3StreamTransferIsScheduled(PHDASTREAM pStream);
+uint64_t          hdaR3StreamTransferGetNext(PHDASTREAM pStream);
+int               hdaR3StreamTransfer(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);
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
-bool              hdaStreamRegisterDMAHandlers(PHDASTREAM pStream);
-void              hdaStreamUnregisterDMAHandlers(PHDASTREAM pStream);
+bool              hdaR3StreamRegisterDMAHandlers(PHDASTREAM pStream);
+void              hdaR3StreamUnregisterDMAHandlers(PHDASTREAM pStream);
 # endif /* HDA_USE_DMA_ACCESS_HANDLER */
 /** @} */
@@ -269 +269 @@
  * @{
  */
-DECLCALLBACK(void) hdaStreamTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
+DECLCALLBACK(void) hdaR3StreamTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser);
 /** @} */
 
@@ -277 +277 @@
  */
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-DECLCALLBACK(int) hdaStreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser);
-int               hdaStreamAsyncIOCreate(PHDASTREAM pStream);
-int               hdaStreamAsyncIODestroy(PHDASTREAM pStream);
-int               hdaStreamAsyncIONotify(PHDASTREAM pStream);
-void              hdaStreamAsyncIOLock(PHDASTREAM pStream);
-void              hdaStreamAsyncIOUnlock(PHDASTREAM pStream);
-void              hdaStreamAsyncIOEnable(PHDASTREAM pStream, bool fEnable);
+DECLCALLBACK(int) hdaR3StreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser);
+int               hdaR3StreamAsyncIOCreate(PHDASTREAM pStream);
+int               hdaR3StreamAsyncIODestroy(PHDASTREAM pStream);
+int               hdaR3StreamAsyncIONotify(PHDASTREAM pStream);
+void              hdaR3StreamAsyncIOLock(PHDASTREAM pStream);
+void              hdaR3StreamAsyncIOUnlock(PHDASTREAM pStream);
+void              hdaR3StreamAsyncIOEnable(PHDASTREAM pStream, bool fEnable);
 # endif /* VBOX_WITH_AUDIO_HDA_ASYNC_IO */
 /** @} */

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

@@ -35 +35 @@
  * @param   fFlags
  */
-int hdaStreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags)
+int hdaR3StreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags)
 {
     int rc = RTCircBufCreate(&pChanData->pCircBuf, 256); /** @todo Make this configurable? */
@@ -51 +51 @@
  * @param   pChanData           Channel data to destroy.
  */
-void hdaStreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData)
+void hdaR3StreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData)
 {
     if (!pChanData)
@@ -73 +73 @@
  * @param   cbBuf               Size (in bytes) of audio data to extract.
  */
-int hdaStreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf)
+int hdaR3StreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf)
 {
     AssertPtrReturn(pChan, VERR_INVALID_POINTER);
@@ -130 +130 @@
  * @remark  Currently not used / implemented.
  */
-int hdaStreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv)
+int hdaR3StreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv)
 {
     AssertPtrReturn(pChan, VERR_INVALID_POINTER);
@@ -142 +142 @@
 /**
  * Acquires (reads) audio channel data.
- * Must be released when done with hdaStreamChannelReleaseData().
+ * Must be released when done with hdaR3StreamChannelReleaseData().
  *
  * @returns IPRT status code.
@@ -149 +149 @@
  * @param   pcbData             Size (in bytes) of acquired data.
  */
-int hdaStreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void **ppvData, size_t *pcbData)
+int hdaR3StreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void **ppvData, size_t *pcbData)
 {
     AssertPtrReturn(pChanData, VERR_INVALID_POINTER);
@@ -162 +162 @@
 
 /**
- * Releases formerly acquired data by hdaStreamChannelAcquireData().
+ * Releases formerly acquired data by hdaR3StreamChannelAcquireData().
  *
  * @returns IPRT status code.
  * @param   pChanData           Channel data to release formerly acquired data for.
  */
-int hdaStreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData)
+int hdaR3StreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData)
 {
     AssertPtrReturn(pChanData, VERR_INVALID_POINTER);

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

@@ -19 +19 @@
 #define HDA_STREAMCHANNEL_H
 
-int hdaStreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags);
-void hdaStreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData);
-int hdaStreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf);
-int hdaStreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv);
-int hdaStreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void *ppvData, size_t *pcbData);
-int hdaStreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData);
+int  hdaR3StreamChannelDataInit(PPDMAUDIOSTREAMCHANNELDATA pChanData, uint32_t fFlags);
+void hdaR3StreamChannelDataDestroy(PPDMAUDIOSTREAMCHANNELDATA pChanData);
+int  hdaR3StreamChannelExtract(PPDMAUDIOSTREAMCHANNEL pChan, const void *pvBuf, size_t cbBuf);
+int  hdaR3StreamChannelAdvance(PPDMAUDIOSTREAMCHANNEL pChan, size_t cbAdv);
+int  hdaR3StreamChannelAcquireData(PPDMAUDIOSTREAMCHANNELDATA pChanData, void *ppvData, size_t *pcbData);
+int  hdaR3StreamChannelReleaseData(PPDMAUDIOSTREAMCHANNELDATA pChanData);
 
 #endif /* !HDA_STREAMCHANNEL_H */

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

@@ -42 +42 @@
  * @param   pProps              Pointer to PCM properties to use for initialization.
  */
-int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps)
+int hdaR3StreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps)
 {
     AssertPtrReturn(pMapping, VERR_INVALID_POINTER);
@@ -50 +50 @@
         return VERR_INVALID_PARAMETER;
 
-    hdaStreamMapReset(pMapping);
+    hdaR3StreamMapReset(pMapping);
 
     pMapping->paChannels = (PPDMAUDIOSTREAMCHANNEL)RTMemAlloc(sizeof(PDMAUDIOSTREAMCHANNEL) * pProps->cChannels);
@@ -70 +70 @@
         pChan->cbOff    = pChan->cbFirst;
 
-        int rc2 = hdaStreamChannelDataInit(&pChan->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE);
+        int rc2 = hdaR3StreamChannelDataInit(&pChan->Data, PDMAUDIOSTREAMCHANNELDATA_FLAG_NONE);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -106 +106 @@
  * @param   pMapping            Pointer to mapping to destroy.
  */
-void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping)
+void hdaR3StreamMapDestroy(PHDASTREAMMAPPING pMapping)
 {
-    hdaStreamMapReset(pMapping);
+    hdaR3StreamMapReset(pMapping);
 
     if (pMapping->pCircBuf)
@@ -123 +123 @@
  * @param   pMapping            Pointer to mapping to reset.
  */
-void hdaStreamMapReset(PHDASTREAMMAPPING pMapping)
+void hdaR3StreamMapReset(PHDASTREAMMAPPING pMapping)
 {
     AssertPtrReturnVoid(pMapping);
@@ -132 +132 @@
     {
         for (uint8_t i = 0; i < pMapping->cChannels; i++)
-            hdaStreamChannelDataDestroy(&pMapping->paChannels[i].Data);
+            hdaR3StreamChannelDataDestroy(&pMapping->paChannels[i].Data);
 
         AssertPtr(pMapping->paChannels);

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

@@ -38 +38 @@
  */
 #ifdef IN_RING3
-int  hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps);
-void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping);
-void hdaStreamMapReset(PHDASTREAMMAPPING pMapping);
+int  hdaR3StreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOPCMPROPS pProps);
+void hdaR3StreamMapDestroy(PHDASTREAMMAPPING pMapping);
+void hdaR3StreamMapReset(PHDASTREAMMAPPING pMapping);
 #endif /* IN_RING3 */
 /** @} */

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

@@ -48 +48 @@
  * @param   pPeriod             Stream period to initialize.
  */
-int hdaStreamPeriodCreate(PHDASTREAMPERIOD pPeriod)
+int hdaR3StreamPeriodCreate(PHDASTREAMPERIOD pPeriod)
 {
     Assert(!(pPeriod->fStatus & HDASTREAMPERIOD_FLAG_VALID));
@@ -64 +64 @@
  * @param   pPeriod             Stream period to destroy.
  */
-void hdaStreamPeriodDestroy(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodDestroy(PHDASTREAMPERIOD pPeriod)
 {
     if (pPeriod->fStatus & HDASTREAMPERIOD_FLAG_VALID)
@@ -78 +78 @@
  *
  * @return  VBox status code.
- * @param   pPeriod             Stream period to (re-)initialize. Must be created with hdaStreamPeriodCreate() first.
+ * @param   pPeriod             Stream period to (re-)initialize. Must be created with hdaR3StreamPeriodCreate() first.
  * @param   u8SD                Stream descriptor (serial data #) number to assign this stream period to.
  * @param   u16LVI              The HDA stream's LVI value to use for the period calculation.
@@ -84 +84 @@
  * @param   pStreamCfg          Audio stream configuration to use for this period.
  */
-int hdaStreamPeriodInit(PHDASTREAMPERIOD pPeriod,
-                        uint8_t u8SD, uint16_t u16LVI, uint32_t u32CBL, PPDMAUDIOSTREAMCFG pStreamCfg)
+int hdaR3StreamPeriodInit(PHDASTREAMPERIOD pPeriod,
+                          uint8_t u8SD, uint16_t u16LVI, uint32_t u32CBL, PPDMAUDIOSTREAMCFG pStreamCfg)
 {
     if (   !u16LVI
@@ -111 +111 @@
     pPeriod->u64StartWalClk    = 0;
     pPeriod->u32Hz             = pStreamCfg->Props.uHz;
-    pPeriod->u64DurationWalClk = hdaStreamPeriodFramesToWalClk(pPeriod, framesToTransfer);
+    pPeriod->u64DurationWalClk = hdaR3StreamPeriodFramesToWalClk(pPeriod, framesToTransfer);
     pPeriod->u64ElapsedWalClk  = 0;
     pPeriod->i64DelayWalClk    = 0;
@@ -130 +130 @@
  * @param   pPeriod             Stream period to reset.
  */
-void hdaStreamPeriodReset(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodReset(PHDASTREAMPERIOD pPeriod)
 {
     Log3Func(("[SD%RU8]\n", pPeriod->u8SD));
@@ -155 +155 @@
  * @param   u64WalClk           Wall clock (WALCLK) value to set for the period's starting point.
  */
-int hdaStreamPeriodBegin(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk)
+int hdaR3StreamPeriodBegin(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk)
 {
     Assert(!(pPeriod->fStatus & HDASTREAMPERIOD_FLAG_ACTIVE)); /* No nested calls. */
@@ -177 +177 @@
  * @param   pPeriod             Stream period to end life span for.
  */
-void hdaStreamPeriodEnd(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodEnd(PHDASTREAMPERIOD pPeriod)
 {
     Log3Func(("[SD%RU8] Took %zuus\n", pPeriod->u8SD, (RTTimeNanoTS() - pPeriod->Dbg.tsStartNs) / 1000));
@@ -188 +188 @@
               ("%RU8 interrupts for stream #%RU8 still pending -- so ending a period might trigger audio hangs\n",
                pPeriod->cIntPending, pPeriod->u8SD));
-    Assert(hdaStreamPeriodIsComplete(pPeriod));
+    Assert(hdaR3StreamPeriodIsComplete(pPeriod));
 
     pPeriod->fStatus &= ~HDASTREAMPERIOD_FLAG_ACTIVE;
@@ -198 +198 @@
  * @param   pPeriod             Stream period to pause.
  */
-void hdaStreamPeriodPause(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodPause(PHDASTREAMPERIOD pPeriod)
 {
     AssertMsg((pPeriod->fStatus & HDASTREAMPERIOD_FLAG_ACTIVE), ("Period %p already in inactive state\n", pPeriod));
@@ -212 +212 @@
  * @param   pPeriod             Stream period to resume.
  */
-void hdaStreamPeriodResume(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodResume(PHDASTREAMPERIOD pPeriod)
 {
     AssertMsg(!(pPeriod->fStatus & HDASTREAMPERIOD_FLAG_ACTIVE), ("Period %p already in active state\n", pPeriod));
@@ -227 +227 @@
  * @param   pPeriod             Stream period to lock.
  */
-bool hdaStreamPeriodLock(PHDASTREAMPERIOD pPeriod)
+bool hdaR3StreamPeriodLock(PHDASTREAMPERIOD pPeriod)
 {
     return RT_SUCCESS(RTCritSectEnter(&pPeriod->CritSect));
@@ -237 +237 @@
  * @param   pPeriod             Stream period to unlock.
  */
-void hdaStreamPeriodUnlock(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodUnlock(PHDASTREAMPERIOD pPeriod)
 {
     int rc2 = RTCritSectLeave(&pPeriod->CritSect);
@@ -252 +252 @@
  * @remark  Calculation depends on the given stream period and assumes a 24 MHz wall clock counter (WALCLK).
  */
-uint64_t hdaStreamPeriodFramesToWalClk(PHDASTREAMPERIOD pPeriod, uint32_t uFrames)
+uint64_t hdaR3StreamPeriodFramesToWalClk(PHDASTREAMPERIOD pPeriod, uint32_t uFrames)
 {
     /* Prevent division by zero. */
@@ -268 +268 @@
  * @param   pPeriod             Stream period to use.
  */
-uint64_t hdaStreamPeriodGetAbsElapsedWalClk(PHDASTREAMPERIOD pPeriod)
+uint64_t hdaR3StreamPeriodGetAbsElapsedWalClk(PHDASTREAMPERIOD pPeriod)
 {
     return pPeriod->u64StartWalClk
@@ -282 +282 @@
  * @param   pPeriod             Stream period to use.
  */
-uint64_t hdaStreamPeriodGetAbsEndWalClk(PHDASTREAMPERIOD pPeriod)
+uint64_t hdaR3StreamPeriodGetAbsEndWalClk(PHDASTREAMPERIOD pPeriod)
 {
     return pPeriod->u64StartWalClk + pPeriod->u64DurationWalClk;
@@ -293 +293 @@
  * @param   pPeriod             Stream period to return value for.
  */
-uint32_t hdaStreamPeriodGetRemainingFrames(PHDASTREAMPERIOD pPeriod)
+uint32_t hdaR3StreamPeriodGetRemainingFrames(PHDASTREAMPERIOD pPeriod)
 {
     Assert(pPeriod->framesToTransfer >= pPeriod->framesTransferred);
@@ -305 +305 @@
  * @param   pPeriod             Stream period to get status for.
  */
-bool hdaStreamPeriodHasElapsed(PHDASTREAMPERIOD pPeriod)
+bool hdaR3StreamPeriodHasElapsed(PHDASTREAMPERIOD pPeriod)
 {
     return (pPeriod->u64ElapsedWalClk >= pPeriod->u64DurationWalClk);
@@ -318 +318 @@
  * @param   u64WalClk           Absolute wall clock (WALCLK) time to check for.
  */
-bool hdaStreamPeriodHasPassedAbsWalClk(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk)
+bool hdaR3StreamPeriodHasPassedAbsWalClk(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk)
 {
     /* Period not in use? */
@@ -324 +324 @@
         return true; /* ... implies that it has passed. */
 
-    if (hdaStreamPeriodHasElapsed(pPeriod))
+    if (hdaR3StreamPeriodHasElapsed(pPeriod))
         return true; /* Period already has elapsed. */
 
@@ -336 +336 @@
  * @param   pPeriod             Stream period to get status for.
  */
-bool hdaStreamPeriodNeedsInterrupt(PHDASTREAMPERIOD pPeriod)
+bool hdaR3StreamPeriodNeedsInterrupt(PHDASTREAMPERIOD pPeriod)
 {
     return pPeriod->cIntPending > 0;
@@ -349 +349 @@
  *          keeps track of the required (pending) interrupts for a stream period.
  */
-void hdaStreamPeriodAcquireInterrupt(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodAcquireInterrupt(PHDASTREAMPERIOD pPeriod)
 {
     uint32_t cIntPending = pPeriod->cIntPending;
@@ -368 +368 @@
  * @param   pPeriod             Stream period to release pending interrupt for.
  */
-void hdaStreamPeriodReleaseInterrupt(PHDASTREAMPERIOD pPeriod)
+void hdaR3StreamPeriodReleaseInterrupt(PHDASTREAMPERIOD pPeriod)
 {
     Assert(pPeriod->cIntPending);
@@ -383 +383 @@
  * @param   framesInc           Audio frames to add.
  */
-void hdaStreamPeriodInc(PHDASTREAMPERIOD pPeriod, uint32_t framesInc)
+void hdaR3StreamPeriodInc(PHDASTREAMPERIOD pPeriod, uint32_t framesInc)
 {
     pPeriod->framesTransferred += framesInc;
     Assert(pPeriod->framesTransferred <= pPeriod->framesToTransfer);
 
-    pPeriod->u64ElapsedWalClk   = hdaStreamPeriodFramesToWalClk(pPeriod, pPeriod->framesTransferred);
+    pPeriod->u64ElapsedWalClk   = hdaR3StreamPeriodFramesToWalClk(pPeriod, pPeriod->framesTransferred);
     Assert(pPeriod->u64ElapsedWalClk <= pPeriod->u64DurationWalClk);
 
@@ -404 +404 @@
  *          and 2) processed all required audio frames.
  */
-bool hdaStreamPeriodIsComplete(PHDASTREAMPERIOD pPeriod)
+bool hdaR3StreamPeriodIsComplete(PHDASTREAMPERIOD pPeriod)
 {
     const bool fIsComplete = /* Has the period elapsed time-wise? */
-                                hdaStreamPeriodHasElapsed(pPeriod)
+                                hdaR3StreamPeriodHasElapsed(pPeriod)
                              /* All frames transferred? */
                              && pPeriod->framesTransferred >= pPeriod->framesToTransfer;
@@ -422 +422 @@
               fIsComplete ? "COMPLETE" : "NOT COMPLETE YET",
               pPeriod->u64ElapsedWalClk, pPeriod->u64DurationWalClk,
-              hdaStreamPeriodGetAbsElapsedWalClk(pPeriod), pPeriod->u64StartWalClk,
-              hdaStreamPeriodGetAbsEndWalClk(pPeriod), pPeriod->cIntPending));
+              hdaR3StreamPeriodGetAbsElapsedWalClk(pPeriod), pPeriod->u64StartWalClk,
+              hdaR3StreamPeriodGetAbsEndWalClk(pPeriod), pPeriod->cIntPending));
 
     return fIsComplete;

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

@@ -84 +84 @@
 
 #ifdef IN_RING3
-int      hdaStreamPeriodCreate(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodDestroy(PHDASTREAMPERIOD pPeriod);
-int      hdaStreamPeriodInit(PHDASTREAMPERIOD pPeriod, uint8_t u8SD, uint16_t u16LVI, uint32_t u32CBL, PPDMAUDIOSTREAMCFG pStreamCfg);
-void     hdaStreamPeriodReset(PHDASTREAMPERIOD pPeriod);
-int      hdaStreamPeriodBegin(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk);
-void     hdaStreamPeriodEnd(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodPause(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodResume(PHDASTREAMPERIOD pPeriod);
-bool     hdaStreamPeriodLock(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodUnlock(PHDASTREAMPERIOD pPeriod);
-uint64_t hdaStreamPeriodFramesToWalClk(PHDASTREAMPERIOD pPeriod, uint32_t uFrames);
-uint64_t hdaStreamPeriodGetAbsEndWalClk(PHDASTREAMPERIOD pPeriod);
-uint64_t hdaStreamPeriodGetAbsElapsedWalClk(PHDASTREAMPERIOD pPeriod);
-uint32_t hdaStreamPeriodGetRemainingFrames(PHDASTREAMPERIOD pPeriod);
-bool     hdaStreamPeriodHasElapsed(PHDASTREAMPERIOD pPeriod);
-bool     hdaStreamPeriodHasPassedAbsWalClk(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk);
-bool     hdaStreamPeriodNeedsInterrupt(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodAcquireInterrupt(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodReleaseInterrupt(PHDASTREAMPERIOD pPeriod);
-void     hdaStreamPeriodInc(PHDASTREAMPERIOD pPeriod, uint32_t framesInc);
-bool     hdaStreamPeriodIsComplete(PHDASTREAMPERIOD pPeriod);
+int      hdaR3StreamPeriodCreate(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodDestroy(PHDASTREAMPERIOD pPeriod);
+int      hdaR3StreamPeriodInit(PHDASTREAMPERIOD pPeriod, uint8_t u8SD, uint16_t u16LVI, uint32_t u32CBL, PPDMAUDIOSTREAMCFG pStreamCfg);
+void     hdaR3StreamPeriodReset(PHDASTREAMPERIOD pPeriod);
+int      hdaR3StreamPeriodBegin(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk);
+void     hdaR3StreamPeriodEnd(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodPause(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodResume(PHDASTREAMPERIOD pPeriod);
+bool     hdaR3StreamPeriodLock(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodUnlock(PHDASTREAMPERIOD pPeriod);
+uint64_t hdaR3StreamPeriodFramesToWalClk(PHDASTREAMPERIOD pPeriod, uint32_t uFrames);
+uint64_t hdaR3StreamPeriodGetAbsEndWalClk(PHDASTREAMPERIOD pPeriod);
+uint64_t hdaR3StreamPeriodGetAbsElapsedWalClk(PHDASTREAMPERIOD pPeriod);
+uint32_t hdaR3StreamPeriodGetRemainingFrames(PHDASTREAMPERIOD pPeriod);
+bool     hdaR3StreamPeriodHasElapsed(PHDASTREAMPERIOD pPeriod);
+bool     hdaR3StreamPeriodHasPassedAbsWalClk(PHDASTREAMPERIOD pPeriod, uint64_t u64WalClk);
+bool     hdaR3StreamPeriodNeedsInterrupt(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodAcquireInterrupt(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodReleaseInterrupt(PHDASTREAMPERIOD pPeriod);
+void     hdaR3StreamPeriodInc(PHDASTREAMPERIOD pPeriod, uint32_t framesInc);
+bool     hdaR3StreamPeriodIsComplete(PHDASTREAMPERIOD pPeriod);
 #endif /* IN_RING3 */