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

Timestamp:

Dec 6, 2019 12:39:15 PM (5 years ago)

Author:

vboxsync

Message:

DevHDA: Split structures. bugref:9218

Location:

trunk/src/VBox/Devices/Audio

Files:

• DevHDA.cpp (modified) (156 diffs)
• DevHDA.h (modified) (10 diffs)
• DevHDACommon.cpp (modified) (22 diffs)
• DevHDACommon.h (modified) (7 diffs)
• HDACodec.cpp (modified) (5 diffs)
• HDACodec.h (modified) (6 diffs)
• HDAStream.cpp (modified) (88 diffs)
• HDAStream.h (modified) (9 diffs)

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

@@ -24 +24 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#ifdef DEBUG_bird
-# define RT_NO_STRICT /* I'm tried of this crap asserting on save and restore of Maverics guests.  */
-#endif
 #define LOG_GROUP LOG_GROUP_DEV_HDA
 #include <VBox/log.h>
@@ -219 +216 @@
     /** Node for storing this driver in our device driver list of HDASTATE. */
     RTLISTNODER3                       Node;
-    /** Pointer to HDA controller (state). */
-    R3PTRTYPE(PHDASTATE)               pHDAState;
+    /** Pointer to shared HDA device state. */
+    R3PTRTYPE(PHDASTATE)               pHDAStateShared;
+    /** Pointer to the ring-3 HDA device state. */
+    R3PTRTYPE(PHDASTATER3)             pHDAStateR3;
     /** Driver flags. */
     PDMAUDIODRVFLAGS                   fFlags;
@@ -254 +253 @@
 #ifndef VBOX_DEVICE_STRUCT_TESTCASE
 #ifdef IN_RING3
-static void hdaR3GCTLReset(PHDASTATE pThis);
+static void hdaR3GCTLReset(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC);
 #endif
 
@@ -317 +316 @@
  */
 #ifdef IN_RING3
-static int                        hdaR3AddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
-static int                        hdaR3RemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg);
+static int                        hdaR3AddStream(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg);
+static int                        hdaR3RemoveStream(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg);
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
 static DECLCALLBACK(VBOXSTRICTRC) hdaR3DmaAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys,
@@ -331 +330 @@
  */
 #ifdef IN_RING3
-static int hdaR3MixerAddDrvStream(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv);
+static int hdaR3MixerAddDrvStream(PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv);
 #endif
 /** @} */
@@ -564 +563 @@
  * audio periods but did not have the chance to issue their (pending) interrupts yet.
  *
- * @param   pThis               The HDA device state.
- */
-static void hdaR3ReschedulePendingInterrupts(PHDASTATE pThis)
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
+ */
+static void hdaR3ReschedulePendingInterrupts(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC)
 {
     bool fInterrupt = false;
@@ -572 +573 @@
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; ++i)
     {
-        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, i);
-        if (!pStream)
-            continue;
-
-        if (   hdaR3StreamPeriodIsComplete    (&pStream->State.Period)
+        PHDASTREAM pStream = &pThis->aStreams[i];
+        if (   hdaR3StreamPeriodIsComplete(    &pStream->State.Period)
             && hdaR3StreamPeriodNeedsInterrupt(&pStream->State.Period)
-            && hdaR3WalClkSet(pThis, hdaR3StreamPeriodGetAbsElapsedWalClk(&pStream->State.Period), false /* fForce */))
+            && hdaR3WalClkSet(pThis, pThisCC, hdaR3StreamPeriodGetAbsElapsedWalClk(&pStream->State.Period), false /* fForce */))
         {
             fInterrupt = true;
@@ -587 +585 @@
     LogFunc(("fInterrupt=%RTbool\n", fInterrupt));
 
-    HDA_PROCESS_INTERRUPT(pThis->pDevInsR3, pThis);
+    HDA_PROCESS_INTERRUPT(pDevIns, pThis);
 }
 #endif /* IN_RING3 */
@@ -703 +701 @@
  *
  * @returns IPRT status code.
- * @param   pThis               HDA state.
+ *
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state.
  * @param   fLocal              Specify true to synchronize HDA state's CORB buffer with the device state,
  *                              or false to synchronize the device state's RIRB buffer with the HDA state.
@@ -709 +709 @@
  * @todo r=andy Break this up into two functions?
  */
-static int hdaR3CmdSync(PHDASTATE pThis, bool fLocal)
+static int hdaR3CmdSync(PPDMDEVINS pDevIns, PHDASTATE pThis, bool fLocal)
 {
     int rc = VINF_SUCCESS;
@@ -716 +716 @@
         if (pThis->u64CORBBase)
         {
-            AssertPtr(pThis->pu32CorbBuf);
             Assert(pThis->cbCorbBuf);
 
@@ -722 +721 @@
  *        the CORB and PDMDevHlpPCIPhysWrite with RIRB below.  There are
  *        similar unexplained inconsistencies in DevHDACommon.cpp. */
-            rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), pThis->u64CORBBase, pThis->pu32CorbBuf, pThis->cbCorbBuf);
+            rc = PDMDevHlpPhysRead(pDevIns, pThis->u64CORBBase, pThis->au32CorbBuf,
+                                   RT_MIN(pThis->cbCorbBuf, sizeof(pThis->au32CorbBuf)));
             Log(("hdaR3CmdSync/CORB: read %RGp LB %#x (%Rrc)\n", pThis->u64CORBBase, pThis->cbCorbBuf, rc));
             AssertRCReturn(rc, rc);
@@ -731 +731 @@
         if (pThis->u64RIRBBase)
         {
-            AssertPtr(pThis->pu64RirbBuf);
             Assert(pThis->cbRirbBuf);
 
-            rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), pThis->u64RIRBBase, pThis->pu64RirbBuf, pThis->cbRirbBuf);
-            Log(("hdaR3CmdSync/RIRB: phys read %RGp LB %#x (%Rrc)\n", pThis->u64RIRBBase, pThis->pu64RirbBuf, rc));
+            rc = PDMDevHlpPCIPhysWrite(pDevIns, pThis->u64RIRBBase, pThis->au64RirbBuf,
+                                       RT_MIN(pThis->cbRirbBuf, sizeof(pThis->au64RirbBuf)));
+            Log(("hdaR3CmdSync/RIRB: phys read %RGp LB %#x (%Rrc)\n", pThis->u64RIRBBase, pThis->cbRirbBuf, rc));
             AssertRCReturn(rc, rc);
         }
@@ -789 +789 @@
  * This will invoke the HDA codec verb dispatcher.
  *
- * @returns IPRT status code.
- * @param   pThis               HDA state.
- */
-static int hdaR3CORBCmdProcess(PHDASTATE pThis)
-{
-    uint8_t corbRp = HDA_REG(pThis, CORBRP);
-    uint8_t corbWp = HDA_REG(pThis, CORBWP);
-    uint8_t rirbWp = HDA_REG(pThis, RIRBWP);
-
-    Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", corbRp, corbWp, rirbWp));
+ * @returns VBox status code suitable for MMIO write return.
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
+ */
+static int hdaR3CORBCmdProcess(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC)
+{
+    Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
 
     if (!(HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
@@ -808 +806 @@
     Assert(pThis->cbCorbBuf);
 
-    int rc = hdaR3CmdSync(pThis, true /* Sync from guest */);
+    int rc = hdaR3CmdSync(pDevIns, pThis, true /* Sync from guest */);
     AssertRCReturn(rc, rc);
 
+    /*
+     * Prepare local copies of relevant registers.
+     */
     uint16_t cIntCnt = HDA_REG(pThis, RINTCNT) & 0xff;
-
     if (!cIntCnt) /* 0 means 256 interrupts. */
         cIntCnt = HDA_MAX_RINTCNT;
 
-    Log3Func(("START CORB(RP:%x, WP:%x) RIRBWP:%x, RINTCNT:%RU8/%RU8\n",
-              corbRp, corbWp, rirbWp, pThis->u16RespIntCnt, cIntCnt));
-
+    uint32_t const cCorbEntries = RT_MIN(RT_MAX(pThis->cbCorbBuf, 1), sizeof(pThis->au32CorbBuf)) / HDA_CORB_ELEMENT_SIZE;
+    uint8_t const  corbWp       = HDA_REG(pThis, CORBWP) % cCorbEntries;
+    uint8_t        corbRp       = HDA_REG(pThis, CORBRP);
+    uint8_t        rirbWp       = HDA_REG(pThis, RIRBWP);
+
+    /*
+     * The loop.
+     */
+    Log3Func(("START CORB(RP:%x, WP:%x) RIRBWP:%x, RINTCNT:%RU8/%RU8\n", corbRp, corbWp, rirbWp, pThis->u16RespIntCnt, cIntCnt));
     while (corbRp != corbWp)
     {
-        corbRp = (corbRp + 1) % (pThis->cbCorbBuf / HDA_CORB_ELEMENT_SIZE); /* Advance +1 as the first command(s) are at CORBWP + 1. */
-
-        uint32_t uCmd  = pThis->pu32CorbBuf[corbRp];
+        /* Fetch the command from the CORB. */
+        corbRp = (corbRp + 1) /* Advance +1 as the first command(s) are at CORBWP + 1. */ % cCorbEntries;
+        uint32_t const uCmd = pThis->au32CorbBuf[corbRp];
+
+        /*
+         * Execute the command.
+         */
         uint64_t uResp = 0;
-
-        rc = pThis->pCodec->pfnLookup(pThis->pCodec, HDA_CODEC_CMD(uCmd, 0 /* Codec index */), &uResp);
+        rc = pThisCC->pCodec->pfnLookup(pThisCC->pCodec, HDA_CODEC_CMD(uCmd, 0 /* Codec index */), &uResp);
         if (RT_FAILURE(rc))
             LogFunc(("Codec lookup failed with rc=%Rrc\n", rc));
-
-        Log3Func(("Codec verb %08x -> response %016lx\n", uCmd, uResp));
+        Log3Func(("Codec verb %08x -> response %016RX64\n", uCmd, uResp));
 
         if (   (uResp & CODEC_RESPONSE_UNSOLICITED)
@@ -837 +845 @@
             LogFunc(("Unexpected unsolicited response.\n"));
             HDA_REG(pThis, CORBRP) = corbRp;
-
-            /** @todo r=andy No CORB/RIRB syncing to guest required in that case? */
-            return rc;
-        }
-
+            /** @todo r=andy No RIRB syncing to guest required in that case? */
+            /** @todo r=bird: Why isn't RIRBWP updated here.  The response might come
+             *        after already processing several commands, can't it?  (When you think
+             *        about it, it is bascially the same question as Andy is asking.) */
+            return VINF_SUCCESS;
+        }
+
+        /*
+         * Store the response in the RIRB.
+         */
+        AssertCompile(HDA_RIRB_SIZE == RT_ELEMENTS(pThis->au64RirbBuf));
         rirbWp = (rirbWp + 1) % HDA_RIRB_SIZE;
-
-        pThis->pu64RirbBuf[rirbWp] = uResp;
-
+        pThis->au64RirbBuf[rirbWp] = uResp;
+
+        /*
+         * Send interrupt if needed.
+         */
+        bool fSendInterrupt = false;
         pThis->u16RespIntCnt++;
-
-        bool fSendInterrupt = false;
-
-        if (pThis->u16RespIntCnt == cIntCnt) /* Response interrupt count reached? */
+        if (pThis->u16RespIntCnt >= cIntCnt) /* Response interrupt count reached? */
         {
             pThis->u16RespIntCnt = 0; /* Reset internal interrupt response counter. */
@@ -856 +870 @@
             Log3Func(("Response interrupt count reached (%RU16)\n", pThis->u16RespIntCnt));
             fSendInterrupt = true;
-
         }
         else if (corbRp == corbWp) /* Did we reach the end of the current command buffer? */
@@ -863 +876 @@
             fSendInterrupt = true;
         }
-
         if (fSendInterrupt)
         {
@@ -869 +881 @@
             {
                 HDA_REG(pThis, RIRBSTS) |= HDA_RIRBSTS_RINTFL;
-
-                rc = HDA_PROCESS_INTERRUPT(pThis->pDevInsR3, pThis);
+                HDA_PROCESS_INTERRUPT(pDevIns, pThis);
             }
         }
     }
 
-    Log3Func(("END CORB(RP:%x, WP:%x) RIRBWP:%x, RINTCNT:%RU8/%RU8\n",
-              corbRp, corbWp, rirbWp, pThis->u16RespIntCnt, cIntCnt));
-
+    /*
+     * Put register locals back.
+     */
+    Log3Func(("END CORB(RP:%x, WP:%x) RIRBWP:%x, RINTCNT:%RU8/%RU8\n", corbRp, corbWp, rirbWp, pThis->u16RespIntCnt, cIntCnt));
     HDA_REG(pThis, CORBRP) = corbRp;
     HDA_REG(pThis, RIRBWP) = rirbWp;
 
-    rc = hdaR3CmdSync(pThis, false /* Sync to guest */);
-    AssertRCReturn(rc, rc);
-
-    if (RT_FAILURE(rc))
-        AssertRCReturn(rc, rc);
+    /*
+     * Write out the response.
+     */
+    rc = hdaR3CmdSync(pDevIns, pThis, false /* Sync to guest */);
+    AssertRC(rc);
 
     return rc;
@@ -989 +1001 @@
         HDA_REG(pThis, GCTL) &= ~HDA_GCTL_CRST;
 
-        hdaR3GCTLReset(pThis);
+        hdaR3GCTLReset(pDevIns, pThis, PDMDEVINS_2_DATA_CC(pDevIns,  PHDASTATER3));
 #else
         return VINF_IOM_R3_MMIO_WRITE;
@@ -1032 +1044 @@
 /**
  * Returns the current maximum value the wall clock counter can be set to.
+ *
  * This maximum value depends on all currently handled HDA streams and their own current timing.
  *
  * @return  Current maximum value the wall clock counter can be set to.
- * @param   pThis               HDA state.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  *
  * @remark  Does not actually set the wall clock counter.
- */
-static uint64_t hdaR3WalClkGetMax(PHDASTATE pThis)
+ *
+ * @todo r=bird: This function is in the wrong file.
+ */
+static uint64_t hdaR3WalClkGetMax(PHDASTATE pThis, PHDASTATER3 pThisCC)
 {
     const uint64_t u64WalClkCur       = ASMAtomicReadU64(&pThis->u64WalClk);
-    const uint64_t u64FrontAbsWalClk  = pThis->SinkFront.pStream
-                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkFront.pStream->State.Period) : 0;
+    const uint64_t u64FrontAbsWalClk  = pThisCC->SinkFront.pStreamShared
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThisCC->SinkFront.pStreamShared->State.Period)  : 0;
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
 #  error "Implement me!"
 # endif
-    const uint64_t u64LineInAbsWalClk = pThis->SinkLineIn.pStream
-                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkLineIn.pStream->State.Period) : 0;
+    const uint64_t u64LineInAbsWalClk = pThisCC->SinkLineIn.pStreamShared
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThisCC->SinkLineIn.pStreamShared->State.Period) : 0;
 # ifdef VBOX_WITH_HDA_MIC_IN
-    const uint64_t u64MicInAbsWalClk  = pThis->SinkMicIn.pStream
-                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThis->SinkMicIn.pStream->State.Period) : 0;
+    const uint64_t u64MicInAbsWalClk  = pThisCC->SinkMicIn.pStreamShared
+                                      ? hdaR3StreamPeriodGetAbsElapsedWalClk(&pThisCC->SinkMicIn.pStreamShared->State.Period)  : 0;
 # endif
 
@@ -1078 +1094 @@
     *pu32Value = RT_LO_U32(u64WalClkCur);
 
-    Log3Func(("%RU32 (max @ %RU64)\n", *pu32Value, hdaR3WalClkGetMax(pThis)));
+    Log3Func(("%RU32 (max @ %RU64)\n", *pu32Value, hdaR3WalClkGetMax(pThis, PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3))));
     return VINF_SUCCESS;
 #else
@@ -1094 +1110 @@
         if (pThis->cbCorbBuf)
         {
-#ifdef IN_RING3
-            AssertPtr(pThis->pu32CorbBuf);
-            RT_BZERO(pThis->pu32CorbBuf, pThis->cbCorbBuf);
-#else
+            RT_ZERO(pThis->au32CorbBuf);
             return VINF_IOM_R3_MMIO_WRITE;
-#endif
         }
 
@@ -1119 +1131 @@
 
     if (HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA) /* Start DMA engine. */
-        rc = hdaR3CORBCmdProcess(pThis);
+        rc = hdaR3CORBCmdProcess(pDevIns, pThis, PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3));
     else
         LogFunc(("CORB DMA not running, skipping\n"));
@@ -1132 +1144 @@
 static VBOXSTRICTRC hdaRegWriteCORBSIZE(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-#ifdef IN_RING3
     RT_NOREF(pDevIns, iReg);
 
@@ -1159 +1170 @@
 
         uint32_t cbCorbBuf = cEntries * HDA_CORB_ELEMENT_SIZE;
-        Assert(cbCorbBuf <= HDA_CORB_SIZE * HDA_CORB_ELEMENT_SIZE); /* Paranoia. */
+        Assert(cbCorbBuf <= sizeof(pThis->au32CorbBuf)); /* paranoia */
 
         if (cbCorbBuf != pThis->cbCorbBuf)
         {
-            RT_BZERO(pThis->pu32CorbBuf, HDA_CORB_SIZE * HDA_CORB_ELEMENT_SIZE); /* Clear CORB when setting a new size. */
+            RT_ZERO(pThis->au32CorbBuf); /* Clear CORB when setting a new size. */
             pThis->cbCorbBuf = cbCorbBuf;
         }
@@ -1174 +1185 @@
         LogFunc(("CORB DMA is (still) running, skipping\n"));
     return VINF_SUCCESS;
+}
+
+static VBOXSTRICTRC hdaRegWriteCORBSTS(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
+{
+    RT_NOREF(pDevIns, iReg);
+
+    uint32_t v = HDA_REG(pThis, CORBSTS);
+    HDA_REG(pThis, CORBSTS) &= ~(v & u32Value);
+
+    return VINF_SUCCESS;
+}
+
+static VBOXSTRICTRC hdaRegWriteCORBWP(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
+{
+#ifdef IN_RING3
+    VBOXSTRICTRC rc = hdaRegWriteU16(pDevIns, pThis, iReg, u32Value);
+    AssertRCSuccess(VBOXSTRICTRC_VAL(rc));
+
+    return hdaR3CORBCmdProcess(pDevIns, pThis, PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3));
 #else
     RT_NOREF(pDevIns, pThis, iReg, u32Value);
@@ -1180 +1210 @@
 }
 
-static VBOXSTRICTRC hdaRegWriteCORBSTS(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-    RT_NOREF(pDevIns, iReg);
-
-    uint32_t v = HDA_REG(pThis, CORBSTS);
-    HDA_REG(pThis, CORBSTS) &= ~(v & u32Value);
-
-    return VINF_SUCCESS;
-}
-
-static VBOXSTRICTRC hdaRegWriteCORBWP(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
+static VBOXSTRICTRC hdaRegWriteSDCBL(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
+{
+    return hdaRegWriteU32(pDevIns, pThis, iReg, u32Value);
+}
+
+static VBOXSTRICTRC hdaRegWriteSDCTL(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
 #ifdef IN_RING3
-    VBOXSTRICTRC rc = hdaRegWriteU16(pDevIns, pThis, iReg, u32Value);
-    AssertRCSuccess(VBOXSTRICTRC_VAL(rc));
-
-    return hdaR3CORBCmdProcess(pThis);
-#else
-    RT_NOREF(pDevIns, pThis, iReg, u32Value);
-    return VINF_IOM_R3_MMIO_WRITE;
-#endif
-}
-
-static VBOXSTRICTRC hdaRegWriteSDCBL(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-    return hdaRegWriteU32(pDevIns, pThis, iReg, u32Value);
-}
-
-static VBOXSTRICTRC hdaRegWriteSDCTL(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-#ifdef IN_RING3
-    /* Get the stream descriptor. */
+    /* Get the stream descriptor number. */
     const uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, CTL, iReg);
+    AssertReturn(uSD < RT_ELEMENTS(pThis->aStreams), VERR_INTERNAL_ERROR_3); /* paranoia^2: Bad g_aHdaRegMap. */
 
     /*
@@ -1221 +1229 @@
      * So depending on the guest OS, SD3 can use stream tag 4, for example.
      */
-    uint8_t uTag = (u32Value >> HDA_SDCTL_NUM_SHIFT) & HDA_SDCTL_NUM_MASK;
-    ASSERT_GUEST_MSG_RETURN(uTag < RT_ELEMENTS(pThis->aTags),
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    uint8_t     uTag    = (u32Value >> HDA_SDCTL_NUM_SHIFT) & HDA_SDCTL_NUM_MASK;
+    ASSERT_GUEST_MSG_RETURN(uTag < RT_ELEMENTS(pThisCC->aTags),
                             ("SD%RU8: Invalid stream tag %RU8 (u32Value=%#x)!\n", uSD, uTag, u32Value),
                             VINF_SUCCESS /* Always return success to the MMIO handler. */);
 
-    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
-    ASSERT_GUEST_LOGREL_MSG_RETURN(pStream, ("Guest tried writing SDCTL (0x%x) to unhandled stream #%RU8\n", u32Value, uSD),
-                                   VINF_SUCCESS /* Always return success to the MMIO handler. */);
+    PHDASTREAM   const pStreamShared = &pThis->aStreams[uSD];
+    PHDASTREAMR3 const pStreamR3     = &pThisCC->aStreams[uSD];
 
     const bool fRun      = RT_BOOL(u32Value & HDA_SDCTL_RUN);
@@ -1242 +1250 @@
     {
         DEVHDA_UNLOCK(pDevIns, pThis);
-        DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, pStream, VINF_IOM_R3_MMIO_WRITE);
+        DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, pStreamShared, VINF_IOM_R3_MMIO_WRITE);
     }
 
@@ -1256 +1264 @@
 
         /* Exit reset state. */
-        ASMAtomicXchgBool(&pStream->State.fInReset, false);
+        ASMAtomicXchgBool(&pStreamShared->State.fInReset, false);
 
         /* Report that we're done resetting this stream by clearing SRST. */
@@ -1270 +1278 @@
         LogFunc(("[SD%RU8] Reset enter\n", uSD));
 
-        hdaR3StreamLock(pStream);
+        hdaR3StreamLock(pStreamR3);
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-        hdaR3StreamAsyncIOLock(pStream);
+        hdaR3StreamAsyncIOLock(pStreamR3);
 # endif
         /* Make sure to remove the run bit before doing the actual stream reset. */
         HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_SDCTL_RUN;
 
-        hdaR3StreamReset(pThis, pStream, pStream->u8SD);
+        hdaR3StreamReset(pThis, pThisCC, pStreamShared, pStreamR3, uSD);
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-        hdaR3StreamAsyncIOUnlock(pStream);
+        hdaR3StreamAsyncIOUnlock(pStreamR3);
 # endif
-        hdaR3StreamUnlock(pStream);
+        hdaR3StreamUnlock(pStreamR3);
     }
     else
@@ -1295 +1303 @@
             LogFunc(("[SD%RU8] State changed (fRun=%RTbool)\n", uSD, fRun));
 
-            hdaR3StreamLock(pStream);
+            hdaR3StreamLock(pStreamR3);
 
             int rc2 = VINF_SUCCESS;
@@ -1301 +1309 @@
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
             if (fRun)
-                rc2 = hdaR3StreamAsyncIOCreate(pStream);
-
-            hdaR3StreamAsyncIOLock(pStream);
+                rc2 = hdaR3StreamAsyncIOCreate(pStreamR3);
+
+            hdaR3StreamAsyncIOLock(pStreamR3);
 # endif
             if (fRun)
@@ -1316 +1324 @@
                 }
 
-                PHDATAG pTag = &pThis->aTags[uTag];
-                AssertPtr(pTag);
-
+                /* Assign new values. */
                 LogFunc(("[SD%RU8] Using stream tag=%RU8\n", uSD, uTag));
-
-                /* Assign new values. */
-                pTag->uTag    = uTag;
-                pTag->pStream = hdaGetStreamFromSD(pThis, uSD);
+                PHDATAG pTag = &pThisCC->aTags[uTag];
+                pTag->uTag      = uTag;
+                pTag->pStreamR3 = &pThisCC->aStreams[uSD];
 
 # ifdef LOG_ENABLED
                 PDMAUDIOPCMPROPS Props;
-                rc2 = hdaR3SDFMTToPCMProps(HDA_STREAM_REG(pThis, FMT, pStream->u8SD), &Props);
+                rc2 = hdaR3SDFMTToPCMProps(HDA_STREAM_REG(pThis, FMT, uSD), &Props);
                 AssertRC(rc2);
                 LogFunc(("[SD%RU8] %RU32Hz, %RU8bit, %RU8 channel(s)\n",
-                         pStream->u8SD, Props.uHz, Props.cbSample * 8 /* Bit */, Props.cChannels));
+                         uSD, Props.uHz, Props.cbSample * 8 /* Bit */, Props.cChannels));
 # endif
                 /* (Re-)initialize the stream with current values. */
-                rc2 = hdaR3StreamInit(pDevIns, pStream, pStream->u8SD);
+                rc2 = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, pStreamR3, uSD);
                 if (   RT_SUCCESS(rc2)
                     /* Any vital stream change occurred so that we need to (re-)add the stream to our setup?
@@ -1340 +1345 @@
                 {
                     /* Remove the old stream from the device setup. */
-                    rc2 = hdaR3RemoveStream(pThis, &pStream->State.Cfg);
+                    rc2 = hdaR3RemoveStream(pThisCC, &pStreamShared->State.Cfg);
                     AssertRC(rc2);
 
                     /* Add the stream to the device setup. */
-                    rc2 = hdaR3AddStream(pThis, &pStream->State.Cfg);
+                    rc2 = hdaR3AddStream(pThisCC, &pStreamShared->State.Cfg);
                     AssertRC(rc2);
                 }
@@ -1352 +1357 @@
             {
                 /* Enable/disable the stream. */
-                rc2 = hdaR3StreamEnable(pStream, fRun /* fEnable */);
+                rc2 = hdaR3StreamEnable(pStreamShared, pStreamR3, fRun /* fEnable */);
                 AssertRC(rc2);
 
@@ -1358 +1363 @@
                 {
                     /* Keep track of running streams. */
-                    pThis->cStreamsActive++;
+                    pThisCC->cStreamsActive++;
 
                     /* (Re-)init the stream's period. */
-                    hdaR3StreamPeriodInit(&pStream->State.Period,
-                                          pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
+                    hdaR3StreamPeriodInit(&pStreamShared->State.Period, uSD, pStreamShared->u16LVI,
+                                          pStreamShared->u32CBL, &pStreamShared->State.Cfg);
 
                     /* Begin a new period for this stream. */
-                    rc2 = hdaR3StreamPeriodBegin(&pStream->State.Period, hdaWalClkGetCurrent(pThis)/* Use current wall clock time */);
+                    rc2 = hdaR3StreamPeriodBegin(&pStreamShared->State.Period,
+                                                 hdaWalClkGetCurrent(pThis) /* Use current wall clock time */);
                     AssertRC(rc2);
 
-                    uint64_t const tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
-                    rc2 = hdaR3TimerSet(pDevIns, pStream, tsNow + pStream->State.cTransferTicks, false /* fForce */, tsNow);
+                    uint64_t const tsNow = PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer);
+                    rc2 = hdaR3TimerSet(pDevIns, pStreamShared, tsNow + pStreamShared->State.cTransferTicks, false /* fForce */, tsNow);
                     AssertRC(rc2);
                 }
@@ -1375 +1381 @@
                 {
                     /* Keep track of running streams. */
-                    Assert(pThis->cStreamsActive);
-                    if (pThis->cStreamsActive)
-                        pThis->cStreamsActive--;
+                    Assert(pThisCC->cStreamsActive);
+                    if (pThisCC->cStreamsActive)
+                        pThisCC->cStreamsActive--;
 
                     /* Make sure to (re-)schedule outstanding (delayed) interrupts. */
-                    hdaR3ReschedulePendingInterrupts(pThis);
+                    hdaR3ReschedulePendingInterrupts(pDevIns, pThis, pThisCC);
 
                     /* Reset the period. */
-                    hdaR3StreamPeriodReset(&pStream->State.Period);
+                    hdaR3StreamPeriodReset(&pStreamShared->State.Period);
                 }
             }
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-            hdaR3StreamAsyncIOUnlock(pStream);
+            hdaR3StreamAsyncIOUnlock(pStreamR3);
 # endif
             /* Make sure to leave the lock before (eventually) starting the timer. */
-            hdaR3StreamUnlock(pStream);
+            hdaR3StreamUnlock(pStreamR3);
         }
     }
 
     if (fNeedVirtualSyncClockLock)
-        PDMDevHlpTimerUnlockClock(pDevIns, pStream->hTimer); /* Caller will unlock pThis->CritSect. */
+        PDMDevHlpTimerUnlockClock(pDevIns, pStreamShared->hTimer); /* Caller will unlock pThis->CritSect. */
 
     return hdaRegWriteU24(pDevIns, pThis, iReg, u32Value);
@@ -1409 +1415 @@
 #ifdef IN_RING3
     const uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, STS, iReg);
-    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
-    ASSERT_GUEST_LOGREL_MSG_RETURN(pStream, ("Guest tried writing SDSTS (0x%x) to unhandled stream #%RU8\n", u32Value, uSD),
-                                   VINF_SUCCESS);
+    AssertReturn(uSD < RT_ELEMENTS(pThis->aStreams), VERR_INTERNAL_ERROR_3); /* paranoia^2: Bad g_aHdaRegMap. */
+    PHDASTATER3 const  pThisCC       = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    PHDASTREAMR3 const pStreamR3     = &pThisCC->aStreams[uSD];
+    PHDASTREAM const   pStreamShared = &pThis->aStreams[uSD];
 
     /* We only need to take the virtual-sync lock if we want to call
        PDMDevHlpTimerGet or hdaR3TimerSet later.  Only precondition for that
        is that we've got a non-zero ticks-per-transfer value. */
-    uint64_t const cTransferTicks = pStream->State.cTransferTicks;
+    uint64_t const cTransferTicks = pStreamShared->State.cTransferTicks;
     if (cTransferTicks)
     {
         DEVHDA_UNLOCK(pDevIns, pThis);
-        DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, pStream, VINF_IOM_R3_MMIO_WRITE);
-    }
-
-    hdaR3StreamLock(pStream);
+        DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, pStreamShared, VINF_IOM_R3_MMIO_WRITE);
+    }
+
+    hdaR3StreamLock(pStreamR3);
 
     uint32_t v = HDA_REG_IND(pThis, iReg);
@@ -1438 +1445 @@
     /* Some guests tend to write SDnSTS even if the stream is not running.
      * So make sure to check if the RUN bit is set first. */
-    const bool fRunning = pStream->State.fRunning;
-
-    Log3Func(("[SD%RU8] fRunning=%RTbool %R[sdsts]\n", pStream->u8SD, fRunning, v));
-
-    PHDASTREAMPERIOD pPeriod = &pStream->State.Period;
+    const bool fRunning = pStreamShared->State.fRunning;
+
+    Log3Func(("[SD%RU8] fRunning=%RTbool %R[sdsts]\n", uSD, fRunning, v));
+
+    PHDASTREAMPERIOD pPeriod = &pStreamShared->State.Period;
     hdaR3StreamPeriodLock(pPeriod);
     if (hdaR3StreamPeriodNeedsInterrupt(pPeriod))
@@ -1450 +1457 @@
         /* 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 = hdaR3WalClkGetMax(pThis);
+        const uint64_t uWalClkMax = hdaR3WalClkGetMax(pThis, PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3));
         if (uWalClkMax > hdaWalClkGetCurrent(pThis))
-            hdaR3WalClkSet(pThis, uWalClkMax, false /* fForce */);
+            hdaR3WalClkSet(pThis, pThisCC, uWalClkMax, false /* fForce */);
 
         hdaR3StreamPeriodEnd(pPeriod);
@@ -1466 +1473 @@
      * ...
      */
-    uint64_t cTicksToNext = pStream->State.cTransferTicks;
+    uint64_t cTicksToNext = pStreamShared->State.cTransferTicks;
     Assert(cTicksToNext == cTicksToNext);
     if (cTicksToNext) /* Only do any calculations if the stream currently is set up for transfers. */
     {
-        const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
-        Assert(tsNow >= pStream->State.tsTransferLast);
-
-        const uint64_t cTicksElapsed     = tsNow - pStream->State.tsTransferLast;
+        const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer);
+        Assert(tsNow >= pStreamShared->State.tsTransferLast);
+
+        const uint64_t cTicksElapsed     = tsNow - pStreamShared->State.tsTransferLast;
 # ifdef LOG_ENABLED
-        const uint64_t cTicksTransferred = pStream->State.cbTransferProcessed * pStream->State.cTicksPerByte;
+        const uint64_t cTicksTransferred = pStreamShared->State.cbTransferProcessed * pStreamShared->State.cTicksPerByte;
 # endif
 
         Log3Func(("[SD%RU8] cTicksElapsed=%RU64, cTicksTransferred=%RU64, cTicksToNext=%RU64\n",
-                  pStream->u8SD, cTicksElapsed, cTicksTransferred, cTicksToNext));
-
-        Log3Func(("[SD%RU8] cbTransferProcessed=%RU32, cbTransferChunk=%RU32, cbTransferSize=%RU32\n",
-                  pStream->u8SD, pStream->State.cbTransferProcessed, pStream->State.cbTransferChunk, pStream->State.cbTransferSize));
+                  uSD, cTicksElapsed, cTicksTransferred, cTicksToNext));
+
+        Log3Func(("[SD%RU8] cbTransferProcessed=%RU32, cbTransferChunk=%RU32, cbTransferSize=%RU32\n", uSD,
+                  pStreamShared->State.cbTransferProcessed, pStreamShared->State.cbTransferChunk, pStreamShared->State.cbTransferSize));
 
         if (cTicksElapsed <= cTicksToNext)
@@ -1489 +1496 @@
         {
             Log3Func(("[SD%RU8] Warning: Lagging behind (%RU64 ticks elapsed, maximum allowed is %RU64)\n",
-                     pStream->u8SD, cTicksElapsed, cTicksToNext));
-
-            LogRelMax2(64, ("HDA: Stream #%RU8 interrupt lagging behind (expected %uus, got %uus), trying to catch up ...\n",
-                            pStream->u8SD,
-                            (PDMDevHlpTimerGetFreq(pDevIns, pStream->hTimer) / pThis->uTimerHz) / 1000,
-                            (tsNow - pStream->State.tsTransferLast) / 1000));
+                     uSD, cTicksElapsed, cTicksToNext));
+
+            LogRelMax2(64, ("HDA: Stream #%RU8 interrupt lagging behind (expected %uus, got %uus), trying to catch up ...\n", uSD,
+                            (PDMDevHlpTimerGetFreq(pDevIns, pStreamShared->hTimer) / pThis->uTimerHz) / 1000,
+                            (tsNow - pStreamShared->State.tsTransferLast) / 1000));
 
             cTicksToNext = 0;
         }
 
-        Log3Func(("[SD%RU8] -> cTicksToNext=%RU64\n", pStream->u8SD, cTicksToNext));
+        Log3Func(("[SD%RU8] -> cTicksToNext=%RU64\n", uSD, cTicksToNext));
 
         /* Reset processed data counter. */
-        pStream->State.cbTransferProcessed = 0;
-        pStream->State.tsTransferNext      = tsNow + cTicksToNext;
+        pStreamShared->State.cbTransferProcessed = 0;
+        pStreamShared->State.tsTransferNext      = tsNow + cTicksToNext;
 
         /* Only re-arm the timer if there were pending transfer interrupts left
          *  -- it could happen that we land in here if a guest writes to SDnSTS
          * unconditionally. */
-        if (pStream->State.cTransferPendingInterrupts)
-        {
-            pStream->State.cTransferPendingInterrupts--;
+        if (pStreamShared->State.cTransferPendingInterrupts)
+        {
+            pStreamShared->State.cTransferPendingInterrupts--;
 
             /* Re-arm the timer. */
-            LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-            hdaR3TimerSet(pDevIns, pStream, tsNow + cTicksToNext, true /* fForce - we just set tsTransferNext*/, 0 /*tsNow*/);
+            LogFunc(("Timer set SD%RU8\n", uSD));
+            hdaR3TimerSet(pDevIns, pStreamShared, tsNow + cTicksToNext,
+                          true /* fForce - we just set tsTransferNext*/, 0 /*tsNow*/);
         }
     }
 
     if (cTransferTicks)
-        PDMDevHlpTimerUnlockClock(pDevIns, pStream->hTimer); /* Caller will unlock pThis->CritSect. */
-    hdaR3StreamUnlock(pStream);
+        PDMDevHlpTimerUnlockClock(pDevIns, pStreamShared->hTimer); /* Caller will unlock pThis->CritSect. */
+    hdaR3StreamUnlock(pStreamR3);
     return VINF_SUCCESS;
 #else  /* !IN_RING3 */
@@ -1530 +1537 @@
 static VBOXSTRICTRC hdaRegWriteSDLVI(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    const uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, LVI, iReg);
+    const size_t idxStream = HDA_SD_NUM_FROM_REG(pThis, LVI, iReg);
+    AssertReturn(idxStream < RT_ELEMENTS(pThis->aStreams), VERR_INTERNAL_ERROR_3); /* paranoia^2: Bad g_aHdaRegMap. */
 
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
@@ -1537 +1545 @@
         /* Try registering the DMA handlers.
          * As we can't be sure in which order LVI + BDL base are set, try registering in both routines. */
-        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
+        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, idxStream);
         if (   pStream
             && hdaR3StreamRegisterDMAHandlers(pThis, pStream))
@@ -1545 +1553 @@
 
     ASSERT_GUEST_LOGREL_MSG(u32Value <= UINT8_MAX, /* Should be covered by the register write mask, but just to make sure. */
-                            ("LVI for stream #%RU8 must not be bigger than %RU8\n", uSD, UINT8_MAX - 1));
+                            ("LVI for stream #%zu must not be bigger than %RU8\n", idxStream, UINT8_MAX - 1));
     return hdaRegWriteU16(pDevIns, pThis, iReg, u32Value);
 }
@@ -1551 +1559 @@
 static VBOXSTRICTRC hdaRegWriteSDFIFOW(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
-
-    if (RT_LIKELY(hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)) /* FIFOW for input streams only. */
+    size_t const idxStream = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
+    AssertReturn(idxStream < RT_ELEMENTS(pThis->aStreams), VERR_INTERNAL_ERROR_3); /* paranoia^2: Bad g_aHdaRegMap. */
+
+    if (RT_LIKELY(hdaGetDirFromSD((uint8_t)idxStream) == PDMAUDIODIR_IN)) /* FIFOW for input streams only. */
     { /* likely */ }
     else
     {
 #ifndef IN_RING0
-        LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to output stream #%RU8, ignoring\n", uSD));
+        LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to output stream #%RU8, ignoring\n", idxStream));
         return VINF_SUCCESS;
 #else
@@ -1565 +1574 @@
     }
 
-    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg));
-    if (pStream)
-    {
-        uint32_t u32FIFOW = 0;
-        switch (u32Value)
-        {
-            case HDA_SDFIFOW_8B:
-            case HDA_SDFIFOW_16B:
-            case HDA_SDFIFOW_32B:
-                u32FIFOW = u32Value;
-                break;
-            default:
-                ASSERT_GUEST_LOGREL_MSG_FAILED(("Guest tried writing unsupported FIFOW (0x%x) to stream #%RU8, defaulting to 32 bytes\n",
-                                                u32Value, uSD));
-                u32FIFOW = HDA_SDFIFOW_32B;
-                break;
-        }
-
-        if (u32FIFOW) /** @todo r=bird: Logic error. it will never be zero, so why this check? */
-        {
-            pStream->u16FIFOW = hdaSDFIFOWToBytes(u32FIFOW);
-            LogFunc(("[SD%RU8] Updating FIFOW to %RU32 bytes\n", uSD, pStream->u16FIFOW));
-            return hdaRegWriteU16(pDevIns, pThis, iReg, u32FIFOW);
-        }
+    uint32_t u32FIFOW = 0;
+    switch (u32Value)
+    {
+        case HDA_SDFIFOW_8B:
+        case HDA_SDFIFOW_16B:
+        case HDA_SDFIFOW_32B:
+            u32FIFOW = u32Value;
+            break;
+        default:
+            ASSERT_GUEST_LOGREL_MSG_FAILED(("Guest tried writing unsupported FIFOW (0x%zx) to stream #%RU8, defaulting to 32 bytes\n",
+                                            u32Value, idxStream));
+            u32FIFOW = HDA_SDFIFOW_32B;
+            break;
+    }
+
+    if (u32FIFOW) /** @todo r=bird: Logic error. it will never be zero, so why this check? */
+    {
+        pThis->aStreams[idxStream].u16FIFOW = hdaSDFIFOWToBytes(u32FIFOW);
+        LogFunc(("[SD%zu] Updating FIFOW to %u bytes\n", idxStream, pThis->aStreams[idxStream].u16FIFOW));
+        return hdaRegWriteU16(pDevIns, pThis, iReg, u32FIFOW);
     }
     return VINF_SUCCESS;
@@ -1632 +1637 @@
  *
  * @returns IPRT status code.
- * @param   pThis               Device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaR3AddStreamOut(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+static int hdaR3AddStreamOut(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg)
+{
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
@@ -1718 +1722 @@
             pCfg->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cbSample, pCfg->Props.cChannels);
 
-            rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_FRONT, pCfg);
+            rc = hdaCodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_FRONT, pCfg);
         }
 
@@ -1733 +1737 @@
             pCfg->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cbSample, pCfg->Props.cChannels);
 
-            rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE, pCfg);
+            rc = hdaCodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_CENTER_LFE, pCfg);
         }
 
@@ -1747 +1751 @@
             pCfg->Props.cShift      = PDMAUDIOPCMPROPS_MAKE_SHIFT_PARMS(pCfg->Props.cbSample, pCfg->Props.cChannels);
 
-            rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_REAR, pCfg);
+            rc = hdaCodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_REAR, pCfg);
         }
 # endif /* VBOX_WITH_AUDIO_HDA_51_SURROUND */
@@ -1761 +1765 @@
  *
  * @returns IPRT status code.
- * @param   pThis               Device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaR3AddStreamIn(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+static int hdaR3AddStreamIn(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg)
+{
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
@@ -1774 +1777 @@
 
     int rc;
-
     switch (pCfg->u.enmSrc)
     {
         case PDMAUDIORECSRC_LINE:
-        {
-            rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_LINE_IN, pCfg);
+            rc = hdaCodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_LINE_IN, pCfg);
             break;
-        }
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
         case PDMAUDIORECSRC_MIC:
-        {
-            rc = hdaCodecAddStream(pThis->pCodec, PDMAUDIOMIXERCTL_MIC_IN, pCfg);
+            rc = hdaCodecAddStream(pThisCC->pCodec, PDMAUDIOMIXERCTL_MIC_IN, pCfg);
             break;
-        }
 # endif
         default:
@@ -1802 +1800 @@
  *
  * @returns IPRT status code.
- * @param   pThis               Device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   pCfg                Stream configuration to use for adding a stream.
  */
-static int hdaR3AddStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+static int hdaR3AddStream(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg)
+{
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
+    LogFlowFuncEnter();
+
     int rc;
-
-    LogFlowFuncEnter();
-
     switch (pCfg->enmDir)
     {
         case PDMAUDIODIR_OUT:
-            rc = hdaR3AddStreamOut(pThis, pCfg);
+            rc = hdaR3AddStreamOut(pThisCC, pCfg);
             break;
 
         case PDMAUDIODIR_IN:
-            rc = hdaR3AddStreamIn(pThis, pCfg);
+            rc = hdaR3AddStreamIn(pThisCC, pCfg);
             break;
 
@@ -1839 +1835 @@
  *
  * @returns IPRT status code.
- * @param   pThis               Device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   pCfg                Stream configuration to use for removing a stream.
  */
-static int hdaR3RemoveStream(PHDASTATE pThis, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+static int hdaR3RemoveStream(PHDASTATER3 pThisCC, PPDMAUDIOSTREAMCFG pCfg)
+{
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
 
@@ -1898 +1893 @@
         && enmMixerCtl != PDMAUDIOMIXERCTL_UNKNOWN)
     {
-        rc = hdaCodecRemoveStream(pThis->pCodec, enmMixerCtl);
+        rc = hdaCodecRemoveStream(pThisCC->pCodec, enmMixerCtl);
     }
 
@@ -1993 +1988 @@
         HDA_REG(pThis, IRS) = HDA_IRS_ICB;  /* busy */
 
-        uint64_t uResp = 0;
-        int rc2 = pThis->pCodec->pfnLookup(pThis->pCodec, HDA_CODEC_CMD(uCmd, 0 /* LUN */), &uResp);
+        PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+        uint64_t    uResp   = 0;
+        int rc2 = pThisCC->pCodec->pfnLookup(pThisCC->pCodec, HDA_CODEC_CMD(uCmd, 0 /* LUN */), &uResp);
         if (RT_FAILURE(rc2))
             LogFunc(("Codec lookup failed with rc2=%Rrc\n", rc2));
@@ -2028 +2024 @@
             /* Do a RIRB reset. */
             if (pThis->cbRirbBuf)
-            {
-#ifdef IN_RING3
-                Assert(pThis->pu64RirbBuf);
-                RT_BZERO(pThis->pu64RirbBuf, pThis->cbRirbBuf);
-#else
-                return VINF_IOM_R3_MMIO_WRITE;
-#endif
-            }
+                RT_ZERO(pThis->au64RirbBuf);
 
             LogRel2(("HDA: RIRB reset\n"));
@@ -2057 +2046 @@
     VBOXSTRICTRC rc = hdaRegWriteU16(pDevIns, pThis, iReg, u32Value);
     AssertRC(VBOXSTRICTRC_VAL(rc));
+
+    /** @todo r=bird: Shouldn't we make sure the HDASTATE::u16RespIntCnt is below
+     *        the new RINTCNT value?  Or alterantively, make the DMA look take
+     *        this into account instead...  I'll do the later for now. */
 
     LogFunc(("Response interrupt count is now %RU8\n", HDA_REG(pThis, RINTCNT) & 0xFF));
@@ -2116 +2109 @@
     HDA_REG(pThis, RIRBSTS) &= ~(v & u32Value);
 
-    return HDA_PROCESS_INTERRUPT(pDevIns, pThis);
+    HDA_PROCESS_INTERRUPT(pDevIns, pThis);
+    return VINF_SUCCESS;
 }
 
@@ -2123 +2117 @@
 /**
  * Retrieves a corresponding sink for a given mixer control.
- * Returns NULL if no sink is found.
  *
- * @return  PHDAMIXERSINK
- * @param   pThis               HDA state.
+ * @return  Pointer to the sink, NULL if no sink is found.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   enmMixerCtl         Mixer control to get the corresponding sink for.
  */
-static PHDAMIXERSINK hdaR3MixerControlToSink(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
+static PHDAMIXERSINK hdaR3MixerControlToSink(PHDASTATER3 pThisCC, PDMAUDIOMIXERCTL enmMixerCtl)
 {
     PHDAMIXERSINK pSink;
@@ -2138 +2131 @@
             /* Fall through is intentional. */
         case PDMAUDIOMIXERCTL_FRONT:
-            pSink = &pThis->SinkFront;
+            pSink = &pThisCC->SinkFront;
             break;
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
         case PDMAUDIOMIXERCTL_CENTER_LFE:
-            pSink = &pThis->SinkCenterLFE;
+            pSink = &pThisCC->SinkCenterLFE;
             break;
         case PDMAUDIOMIXERCTL_REAR:
-            pSink = &pThis->SinkRear;
+            pSink = &pThisCC->SinkRear;
             break;
 # endif
         case PDMAUDIOMIXERCTL_LINE_IN:
-            pSink = &pThis->SinkLineIn;
+            pSink = &pThisCC->SinkLineIn;
             break;
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
         case PDMAUDIOMIXERCTL_MIC_IN:
-            pSink = &pThis->SinkMicIn;
+            pSink = &pThisCC->SinkMicIn;
             break;
 # endif
         default:
+            AssertMsgFailed(("Unhandled mixer control\n"));
             pSink = NULL;
-            AssertMsgFailed(("Unhandled mixer control\n"));
             break;
     }
@@ -2169 +2162 @@
  *
  * @return IPRT status code.
- * @param  pThis                HDA state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param  pDrv                 HDA driver to add.
  */
-static int hdaR3MixerAddDrv(PHDASTATE pThis, PHDADRIVER pDrv)
+static int hdaR3MixerAddDrv(PHDASTATER3 pThisCC, PHDADRIVER pDrv)
 {
     int rc = VINF_SUCCESS;
 
-    PHDASTREAM pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn);
+    PHDASTREAM pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkLineIn);
     if (   pStream
         && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pThis->SinkLineIn.pMixSink, &pStream->State.Cfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkLineIn.pMixSink, &pStream->State.Cfg, pDrv);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -2186 +2179 @@
 
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn);
+    pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkMicIn);
     if (   pStream
         && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pThis->SinkMicIn.pMixSink, &pStream->State.Cfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkMicIn.pMixSink, &pStream->State.Cfg, pDrv);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -2196 +2189 @@
 # endif
 
-    pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkFront);
+    pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkFront);
     if (   pStream
         && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pThis->SinkFront.pMixSink, &pStream->State.Cfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkFront.pMixSink, &pStream->State.Cfg, pDrv);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -2206 +2199 @@
 
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkCenterLFE);
+    pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkCenterLFE);
     if (   pStream
         && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pThis->SinkCenterLFE.pMixSink, &pStream->State.Cfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkCenterLFE.pMixSink, &pStream->State.Cfg, pDrv);
         if (RT_SUCCESS(rc))
             rc = rc2;
     }
 
-    pStream = hdaR3GetStreamFromSink(pThis, &pThis->SinkRear);
+    pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkRear);
     if (   pStream
         && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pThis->SinkRear.pMixSink, &pStream->State.Cfg, pDrv);
+        int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkRear.pMixSink, &pStream->State.Cfg, pDrv);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -2232 +2225 @@
  * associated streams.
  *
- * @param pThis                 HDA state.
- * @param pDrv                  HDA driver to remove.
- */
-static void hdaR3MixerRemoveDrv(PHDASTATE pThis, PHDADRIVER pDrv)
-{
-    AssertPtrReturnVoid(pThis);
+ * @param   pThisCC             The ring-3 HDA device state.
+ * @param   pDrv                HDA driver to remove.
+ */
+static void hdaR3MixerRemoveDrv(PHDASTATER3 pThisCC, PHDADRIVER pDrv)
+{
     AssertPtrReturnVoid(pDrv);
 
     if (pDrv->LineIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThis->SinkLineIn.pMixSink) == pDrv->LineIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(pThis->SinkLineIn.pMixSink, NULL);
-
-        AudioMixerSinkRemoveStream(pThis->SinkLineIn.pMixSink, pDrv->LineIn.pMixStrm);
+        if (AudioMixerSinkGetRecordingSource(pThisCC->SinkLineIn.pMixSink) == pDrv->LineIn.pMixStrm)
+            AudioMixerSinkSetRecordingSource(pThisCC->SinkLineIn.pMixSink, NULL);
+
+        AudioMixerSinkRemoveStream(pThisCC->SinkLineIn.pMixSink, pDrv->LineIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->LineIn.pMixStrm);
         pDrv->LineIn.pMixStrm = NULL;
@@ -2253 +2245 @@
     if (pDrv->MicIn.pMixStrm)
     {
-        if (AudioMixerSinkGetRecordingSource(pThis->SinkMicIn.pMixSink) == pDrv->MicIn.pMixStrm)
-            AudioMixerSinkSetRecordingSource(&pThis->SinkMicIn.pMixSink, NULL);
-
-        AudioMixerSinkRemoveStream(pThis->SinkMicIn.pMixSink, pDrv->MicIn.pMixStrm);
+        if (AudioMixerSinkGetRecordingSource(pThisCC->SinkMicIn.pMixSink) == pDrv->MicIn.pMixStrm)
+            AudioMixerSinkSetRecordingSource(&pThisCC->SinkMicIn.pMixSink, NULL);
+
+        AudioMixerSinkRemoveStream(pThisCC->SinkMicIn.pMixSink, pDrv->MicIn.pMixStrm);
         AudioMixerStreamDestroy(pDrv->MicIn.pMixStrm);
         pDrv->MicIn.pMixStrm = NULL;
@@ -2264 +2256 @@
     if (pDrv->Front.pMixStrm)
     {
-        AudioMixerSinkRemoveStream(pThis->SinkFront.pMixSink, pDrv->Front.pMixStrm);
+        AudioMixerSinkRemoveStream(pThisCC->SinkFront.pMixSink, pDrv->Front.pMixStrm);
         AudioMixerStreamDestroy(pDrv->Front.pMixStrm);
         pDrv->Front.pMixStrm = NULL;
@@ -2272 +2264 @@
     if (pDrv->CenterLFE.pMixStrm)
     {
-        AudioMixerSinkRemoveStream(pThis->SinkCenterLFE.pMixSink, pDrv->CenterLFE.pMixStrm);
+        AudioMixerSinkRemoveStream(pThisCC->SinkCenterLFE.pMixSink, pDrv->CenterLFE.pMixStrm);
         AudioMixerStreamDestroy(pDrv->CenterLFE.pMixStrm);
         pDrv->CenterLFE.pMixStrm = NULL;
@@ -2279 +2271 @@
     if (pDrv->Rear.pMixStrm)
     {
-        AudioMixerSinkRemoveStream(pThis->SinkRear.pMixSink, pDrv->Rear.pMixStrm);
+        AudioMixerSinkRemoveStream(pThisCC->SinkRear.pMixSink, pDrv->Rear.pMixStrm);
         AudioMixerStreamDestroy(pDrv->Rear.pMixStrm);
         pDrv->Rear.pMixStrm = NULL;
@@ -2292 +2284 @@
  *
  * @returns IPRT status code (ignored by caller).
- * @param   pThis               HDA state.
  * @param   pMixSink            Audio mixer sink to add audio streams to.
  * @param   pCfg                Audio stream configuration to use for the audio streams to add.
  * @param   pDrv                Driver stream to add.
  */
-static int hdaR3MixerAddDrvStream(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv)
-{
-    AssertPtrReturn(pThis,    VERR_INVALID_POINTER);
+static int hdaR3MixerAddDrvStream(PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg, PHDADRIVER pDrv)
+{
     AssertPtrReturn(pMixSink, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,     VERR_INVALID_POINTER);
@@ -2417 +2407 @@
  *
  * @returns IPRT status code.
- * @param   pThis               HDA state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   pMixSink            Audio mixer sink to add stream to.
  * @param   pCfg                Audio stream configuration to use for the audio streams to add.
  */
-static int hdaR3MixerAddDrvStreams(PHDASTATE pThis, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis,    VERR_INVALID_POINTER);
+static int hdaR3MixerAddDrvStreams(PHDASTATER3 pThisCC, PAUDMIXSINK pMixSink, PPDMAUDIOSTREAMCFG pCfg)
+{
     AssertPtrReturn(pMixSink, VERR_INVALID_POINTER);
     AssertPtrReturn(pCfg,     VERR_INVALID_POINTER);
@@ -2437 +2426 @@
 
     PHDADRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
-    {
-        int rc2 = hdaR3MixerAddDrvStream(pThis, pMixSink, pCfg, pDrv);
+    RTListForEach(&pThisCC->lstDrv, pDrv, HDADRIVER, Node)
+    {
+        int rc2 = hdaR3MixerAddDrvStream(pMixSink, pCfg, pDrv);
         if (RT_FAILURE(rc2))
             LogFunc(("Attaching stream failed with %Rrc\n", rc2));
@@ -2452 +2441 @@
 /**
  * @interface_method_impl{HDACODEC,pfnCbMixerAddStream}
- *
- * Adds a new audio stream to a specific mixer control.
- *
- * Depending on the mixer control the stream then gets assigned to one of the internal
- * mixer sinks, which in turn then handle the mixing of all connected streams to that sink.
- *
- * @return  IPRT status code.
- * @param   pThis               HDA state.
- * @param   enmMixerCtl         Mixer control to assign new stream to.
- * @param   pCfg                Stream configuration for the new stream.
- */
-static DECLCALLBACK(int) hdaR3MixerAddStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
+ */
+static DECLCALLBACK(int) hdaR3MixerAddStream(PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg)
+{
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
     AssertPtrReturn(pCfg,  VERR_INVALID_POINTER);
-
     int rc;
 
-    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThisCC, enmMixerCtl);
     if (pSink)
     {
-        rc = hdaR3MixerAddDrvStreams(pThis, pSink->pMixSink, pCfg);
+        rc = hdaR3MixerAddDrvStreams(pThisCC, pSink->pMixSink, pCfg);
 
         AssertPtr(pSink->pMixSink);
@@ -2487 +2465 @@
 /**
  * @interface_method_impl{HDACODEC,pfnCbMixerRemoveStream}
- *
- * Removes a specified mixer control from the HDA's mixer.
- *
- * @return  IPRT status code.
- * @param   pThis               HDA state.
- * @param   enmMixerCtl         Mixer control to remove.
- *
- * @remarks Can be called as a callback by the HDA codec.
- */
-static DECLCALLBACK(int) hdaR3MixerRemoveStream(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl)
-{
-    AssertPtrReturn(pThis, VERR_INVALID_POINTER);
-
-    int rc;
-
-    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
+ */
+static DECLCALLBACK(int) hdaR3MixerRemoveStream(PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl)
+{
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    int         rc;
+
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThisCC, enmMixerCtl);
     if (pSink)
     {
         PHDADRIVER pDrv;
-        RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
+        RTListForEach(&pThisCC->lstDrv, pDrv, HDADRIVER, Node)
         {
             PAUDMIXSTREAM pMixStream = NULL;
@@ -2568 +2537 @@
  * @interface_method_impl{HDACODEC,pfnCbMixerControl}
  *
- * Controls an input / output converter widget, that is, which converter is connected
- * to which stream (and channel).
- *
- * @returns IPRT status code.
- * @param   pThis               HDA State.
- * @param   enmMixerCtl         Mixer control to set SD stream number and channel for.
- * @param   uSD                 SD stream number (number + 1) to set. Set to 0 for unassign.
- * @param   uChannel            Channel to set. Only valid if a valid SD stream number is specified.
- *
- * @remarks Can be called as a callback by the HDA codec.
- */
-static DECLCALLBACK(int) hdaR3MixerControl(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
-{
+ * @note Is also called directly by the DevHDA code.
+ */
+static DECLCALLBACK(int) hdaR3MixerControl(PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel)
+{
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
     LogFunc(("enmMixerCtl=%s, uSD=%RU8, uChannel=%RU8\n", DrvAudioHlpAudMixerCtlToStr(enmMixerCtl), uSD, uChannel));
 
@@ -2606 +2568 @@
     int rc = VINF_SUCCESS;
 
-    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThisCC, enmMixerCtl);
     if (pSink)
     {
@@ -2612 +2574 @@
 
         /* If this an output stream, determine the correct SD#. */
-        if (   (uSD < HDA_MAX_SDI)
+        if (   uSD < HDA_MAX_SDI
             && AudioMixerSinkGetDir(pSink->pMixSink) == AUDMIXSINKDIR_OUTPUT)
-        {
             uSD += HDA_MAX_SDI;
-        }
+
+        /* Make 100% sure we got a good stream number before continuing. */
+        AssertLogRelReturn(uSD < RT_ELEMENTS(pThisCC->aStreams), VERR_NOT_IMPLEMENTED);
 
         /* Detach the existing stream from the sink. */
-        if (   pSink->pStream
-            && (   pSink->pStream->u8SD      != uSD
-                || pSink->pStream->u8Channel != uChannel)
+        if (   pSink->pStreamShared
+            && pSink->pStreamR3
+            && (   pSink->pStreamShared->u8SD      != uSD
+                || pSink->pStreamShared->u8Channel != uChannel)
            )
         {
             LogFunc(("Sink '%s' was assigned to stream #%RU8 (channel %RU8) before\n",
-                     pSink->pMixSink->pszName, pSink->pStream->u8SD, pSink->pStream->u8Channel));
-
-            hdaR3StreamLock(pSink->pStream);
+                     pSink->pMixSink->pszName, pSink->pStreamShared->u8SD, pSink->pStreamShared->u8Channel));
+
+            hdaR3StreamLock(pSink->pStreamR3);
 
             /* Only disable the stream if the stream descriptor # has changed. */
-            if (pSink->pStream->u8SD != uSD)
-                hdaR3StreamEnable(pSink->pStream, false);
-
-            pSink->pStream->pMixSink = NULL;
-
-            hdaR3StreamUnlock(pSink->pStream);
-
-            pSink->pStream = NULL;
-        }
-
-        Assert(uSD < HDA_MAX_STREAMS);
+            if (pSink->pStreamShared->u8SD != uSD)
+                hdaR3StreamEnable(pSink->pStreamShared, pSink->pStreamR3, false /*fEnable*/);
+
+            pSink->pStreamR3->pMixSink = NULL;
+
+            hdaR3StreamUnlock(pSink->pStreamR3);
+
+            pSink->pStreamShared = NULL;
+            pSink->pStreamR3     = NULL;
+        }
 
         /* Attach the new stream to the sink.
          * Enabling the stream will be done by the gust via a separate SDnCTL call then. */
-        if (pSink->pStream == NULL)
+        if (pSink->pStreamShared == NULL)
         {
             LogRel2(("HDA: Setting sink '%s' to stream #%RU8 (channel %RU8), mixer control=%s\n",
                      pSink->pMixSink->pszName, uSD, uChannel, DrvAudioHlpAudMixerCtlToStr(enmMixerCtl)));
 
-            PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
-            if (pStream)
-            {
-                hdaR3StreamLock(pStream);
-
-                pSink->pStream = pStream;
-
-                pStream->u8Channel = uChannel;
-                pStream->pMixSink  = pSink;
-
-                hdaR3StreamUnlock(pStream);
-
-                rc = VINF_SUCCESS;
-            }
-            else
-                rc = VERR_NOT_IMPLEMENTED;
+            PHDASTREAMR3 pStreamR3     = &pThisCC->aStreams[uSD];
+            PHDASTREAM   pStreamShared = &pThis->aStreams[uSD];
+            hdaR3StreamLock(pStreamR3);
+
+            pSink->pStreamR3     = pStreamR3;
+            pSink->pStreamShared = pStreamShared;
+
+            pStreamShared->u8Channel = uChannel;
+            pStreamR3->pMixSink      = pSink;
+
+            hdaR3StreamUnlock(pStreamR3);
+            rc = VINF_SUCCESS;
         }
     }
@@ -2680 +2639 @@
 /**
  * @interface_method_impl{HDACODEC,pfnCbMixerSetVolume}
- *
- * Sets the volume of a specified mixer control.
- *
- * @return  IPRT status code.
- * @param   pThis               HDA State.
- * @param   enmMixerCtl         Mixer control to set volume for.
- * @param   pVol                Pointer to volume data to set.
- *
- * @remarks Can be called as a callback by the HDA codec.
- */
-static DECLCALLBACK(int) hdaR3MixerSetVolume(PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol)
-{
-    int rc;
-
-    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThis, enmMixerCtl);
+ */
+static DECLCALLBACK(int) hdaR3MixerSetVolume(PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol)
+{
+    PHDASTATER3   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    int           rc;
+
+    PHDAMIXERSINK pSink = hdaR3MixerControlToSink(pThisCC, enmMixerCtl);
     if (   pSink
         && pSink->pMixSink)
@@ -2717 +2668 @@
 static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
 {
-    PHDASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-    PHDASTREAM      pStream = (PHDASTREAM)pvUser;
-    TMTIMERHANDLE   hTimer  = pStream->hTimer;
+    PHDASTATE       pThis         = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3     pThisCC       = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    uintptr_t       idxStream     = (uintptr_t)pvUser;
+    AssertReturnVoid(idxStream < RT_ELEMENTS(pThis->aStreams));
+    PHDASTREAM      pStreamShared = &pThis->aStreams[idxStream];
+    PHDASTREAMR3    pStreamR3     = &pThisCC->aStreams[idxStream];
+    TMTIMERHANDLE   hTimer        = pStreamShared->hTimer;
     RT_NOREF(pTimer);
 
-    AssertPtr(pStream);
     Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     Assert(PDMDevHlpTimerIsLockOwner(pDevIns, hTimer));
 
-    hdaR3StreamUpdate(pDevIns, pStream, true /* fInTimer */);
+    hdaR3StreamUpdate(pDevIns, pThis, pThisCC, pStreamShared, pStreamR3, true /* fInTimer */);
 
     /* Flag indicating whether to kick the timer again for a new data processing round. */
     bool fSinkActive = false;
-    if (pStream->pMixSink)
-        fSinkActive = AudioMixerSinkIsActive(pStream->pMixSink->pMixSink);
+    if (pStreamR3->pMixSink)
+        fSinkActive = AudioMixerSinkIsActive(pStreamR3->pMixSink->pMixSink);
 
     if (fSinkActive)
     {
         uint64_t const tsNow = PDMDevHlpTimerGet(pDevIns, hTimer); /* (For virtual sync this remains the same for the whole callout IIRC) */
-        const bool fTimerScheduled = hdaR3StreamTransferIsScheduled(pStream, tsNow);
+        const bool fTimerScheduled = hdaR3StreamTransferIsScheduled(pStreamShared, tsNow);
         Log3Func(("fSinksActive=%RTbool, fTimerScheduled=%RTbool\n", fSinkActive, fTimerScheduled));
         if (!fTimerScheduled)
-            hdaR3TimerSet(pDevIns, pStream, tsNow + PDMDevHlpTimerGetFreq(pDevIns, hTimer) / pThis->uTimerHz,
+            hdaR3TimerSet(pDevIns, pStreamShared, tsNow + PDMDevHlpTimerGetFreq(pDevIns, hTimer) / pThis->uTimerHz,
                           true /*fForce*/, tsNow /*fixed*/ );
     }
@@ -2882 +2836 @@
  * Soft reset of the device triggered via GCTL.
  *
- * @param   pThis   HDA state.
- *
- */
-static void hdaR3GCTLReset(PHDASTATE pThis)
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
+ */
+static void hdaR3GCTLReset(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC)
 {
     LogFlowFuncEnter();
 
-    pThis->cStreamsActive = 0;
+    pThisCC->cStreamsActive = 0;
 
     HDA_REG(pThis, GCAP)     = HDA_MAKE_GCAP(HDA_MAX_SDO, HDA_MAX_SDI, 0, 0, 1); /* see 6.2.1 */
@@ -2908 +2863 @@
      * Stop any audio currently playing and/or recording.
      */
-    pThis->SinkFront.pStream = NULL;
-    if (pThis->SinkFront.pMixSink)
-        AudioMixerSinkReset(pThis->SinkFront.pMixSink);
+    pThisCC->SinkFront.pStreamShared = NULL;
+    pThisCC->SinkFront.pStreamR3     = NULL;
+    if (pThisCC->SinkFront.pMixSink)
+        AudioMixerSinkReset(pThisCC->SinkFront.pMixSink);
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    pThis->SinkMicIn.pStream = NULL;
-    if (pThis->SinkMicIn.pMixSink)
-        AudioMixerSinkReset(pThis->SinkMicIn.pMixSink);
+    pThisCC->SinkMicIn.pStreamShared = NULL;
+    pThisCC->SinkMicIn.pStreamR3     = NULL;
+    if (pThisCC->SinkMicIn.pMixSink)
+        AudioMixerSinkReset(pThisCC->SinkMicIn.pMixSink);
 # endif
-    pThis->SinkLineIn.pStream = NULL;
-    if (pThis->SinkLineIn.pMixSink)
-        AudioMixerSinkReset(pThis->SinkLineIn.pMixSink);
+    pThisCC->SinkLineIn.pStreamShared = NULL;
+    pThisCC->SinkLineIn.pStreamR3     = NULL;
+    if (pThisCC->SinkLineIn.pMixSink)
+        AudioMixerSinkReset(pThisCC->SinkLineIn.pMixSink);
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    pThis->SinkCenterLFE = NULL;
-    if (pThis->SinkCenterLFE.pMixSink)
-        AudioMixerSinkReset(pThis->SinkCenterLFE.pMixSink);
-    pThis->SinkRear.pStream = NULL;
-    if (pThis->SinkRear.pMixSink)
-        AudioMixerSinkReset(pThis->SinkRear.pMixSink);
+    pThisCC->SinkCenterLFE = NULL;
+    if (pThisCC->SinkCenterLFE.pMixSink)
+        AudioMixerSinkReset(pThisCC->SinkCenterLFE.pMixSink);
+    pThisCC->SinkRear.pStreamShared = NULL;
+    pThisCC->SinkRear.pStreamR3     = NULL;
+    if (pThisCC->SinkRear.pMixSink)
+        AudioMixerSinkReset(pThisCC->SinkRear.pMixSink);
 # endif
 
@@ -2931 +2890 @@
      * Reset the codec.
      */
-    if (   pThis->pCodec
-        && pThis->pCodec->pfnReset)
-    {
-        pThis->pCodec->pfnReset(pThis->pCodec);
+    if (   pThisCC->pCodec
+        && pThisCC->pCodec->pfnReset)
+    {
+        pThisCC->pCodec->pfnReset(pThisCC->pCodec);
     }
 
@@ -2944 +2903 @@
      * These stream numbers can be changed by the guest dynamically lateron.
      */
+    ASMCompilerBarrier(); /* paranoia */
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_MIC_IN    , 1 /* SD0 */, 0 /* Channel */);
+    hdaR3MixerControl(pDevIns, PDMAUDIOMIXERCTL_MIC_IN    , 1 /* SD0 */, 0 /* Channel */);
 # endif
-    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_LINE_IN   , 1 /* SD0 */, 0 /* Channel */);
-
-    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_FRONT     , 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pDevIns, PDMAUDIOMIXERCTL_LINE_IN   , 1 /* SD0 */, 0 /* Channel */);
+
+    hdaR3MixerControl(pDevIns, PDMAUDIOMIXERCTL_FRONT     , 5 /* SD4 */, 0 /* Channel */);
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
-    hdaR3MixerControl(pThis, PDMAUDIOMIXERCTL_REAR      , 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pDevIns, PDMAUDIOMIXERCTL_CENTER_LFE, 5 /* SD4 */, 0 /* Channel */);
+    hdaR3MixerControl(pDevIns, PDMAUDIOMIXERCTL_REAR      , 5 /* SD4 */, 0 /* Channel */);
 # endif
+    ASMCompilerBarrier(); /* paranoia */
 
     /* Reset CORB. */
     pThis->cbCorbBuf = HDA_CORB_SIZE * HDA_CORB_ELEMENT_SIZE;
-    RT_BZERO(pThis->pu32CorbBuf, pThis->cbCorbBuf);
+    RT_ZERO(pThis->au32CorbBuf);
 
     /* Reset RIRB. */
     pThis->cbRirbBuf = HDA_RIRB_SIZE * HDA_RIRB_ELEMENT_SIZE;
-    RT_BZERO(pThis->pu64RirbBuf, pThis->cbRirbBuf);
+    RT_ZERO(pThis->au64RirbBuf);
 
     /* Clear our internal response interrupt counter. */
     pThis->u16RespIntCnt = 0;
 
-    for (uint8_t uSD = 0; uSD < HDA_MAX_STREAMS; ++uSD)
-    {
-        int rc2 = hdaR3StreamEnable(&pThis->aStreams[uSD], false /* fEnable */);
+    for (size_t idxStream = 0; idxStream < RT_ELEMENTS(pThis->aStreams); idxStream++)
+    {
+        int rc2 = hdaR3StreamEnable(&pThis->aStreams[idxStream], &pThisCC->aStreams[idxStream], 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;
-            hdaR3StreamReset(pThis, &pThis->aStreams[uSD], uSD);
+            HDA_STREAM_REG(pThis, CTL, idxStream) &= ~HDA_SDCTL_RUN;
+            hdaR3StreamReset(pThis, pThisCC, &pThis->aStreams[idxStream], &pThisCC->aStreams[idxStream], (uint8_t)idxStream);
         }
     }
 
     /* Clear stream tags <-> objects mapping table. */
-    RT_ZERO(pThis->aTags);
+    RT_ZERO(pThisCC->aTags);
 
     /* Emulation of codec "wake up" (HDA spec 5.5.1 and 6.5). */
@@ -3426 +3387 @@
 
 
-static int hdaR3SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStream)
+static int hdaR3SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3)
 {
     PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
@@ -3433 +3394 @@
 # endif
 
-    Log2Func(("[SD%RU8]\n", pStream->u8SD));
+    Log2Func(("[SD%RU8]\n", pStreamShared->u8SD));
 
     /* Save stream ID. */
-    int rc = pHlp->pfnSSMPutU8(pSSM, pStream->u8SD);
+    Assert(pStreamShared->u8SD < HDA_MAX_STREAMS);
+    int rc = pHlp->pfnSSMPutU8(pSSM, pStreamShared->u8SD);
     AssertRCReturn(rc, rc);
-    Assert(pStream->u8SD < HDA_MAX_STREAMS);
-
-    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE), 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
+
+    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStreamShared->State, sizeof(pStreamShared->State),
+                                 0 /*fFlags*/, g_aSSMStreamStateFields7, NULL);
     AssertRCReturn(rc, rc);
 
-    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC), 0 /*fFlags*/, g_aSSMBDLEDescFields7, NULL);
+    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStreamShared->State.BDLE.Desc, sizeof(pStreamShared->State.BDLE.Desc),
+                                 0 /*fFlags*/, g_aSSMBDLEDescFields7, NULL);
     AssertRCReturn(rc, rc);
 
-    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE), 0 /*fFlags*/, g_aSSMBDLEStateFields7, NULL);
+    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStreamShared->State.BDLE.State, sizeof(pStreamShared->State.BDLE.State),
+                                 0 /*fFlags*/,  g_aSSMBDLEStateFields7, NULL);
     AssertRCReturn(rc, rc);
 
-    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD), 0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
+    rc = pHlp->pfnSSMPutStructEx(pSSM, &pStreamShared->State.Period, sizeof(pStreamShared->State.Period),
+                                 0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
     AssertRCReturn(rc, rc);
 
@@ -3455 +3420 @@
     uint32_t cbCircBufUsed = 0;
 
-    if (pStream->State.pCircBuf)
-    {
-        cbCircBufSize = (uint32_t)RTCircBufSize(pStream->State.pCircBuf);
-        cbCircBufUsed = (uint32_t)RTCircBufUsed(pStream->State.pCircBuf);
+    if (pStreamR3->State.pCircBuf)
+    {
+        cbCircBufSize = (uint32_t)RTCircBufSize(pStreamR3->State.pCircBuf);
+        cbCircBufUsed = (uint32_t)RTCircBufUsed(pStreamR3->State.pCircBuf);
     }
 
@@ -3476 +3441 @@
          * So get the current read offset and serialize the buffer data manually based on that.
          */
-        size_t const offBuf = RTCircBufOffsetRead(pStream->State.pCircBuf);
+        size_t const offBuf = RTCircBufOffsetRead(pStreamR3->State.pCircBuf);
         void  *pvBuf;
         size_t cbBuf;
-        RTCircBufAcquireReadBlock(pStream->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
+        RTCircBufAcquireReadBlock(pStreamR3->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
         Assert(cbBuf);
         if (cbBuf)
@@ -3491 +3456 @@
             }
         }
-        RTCircBufReleaseReadBlock(pStream->State.pCircBuf, 0 /* Don't advance read pointer -- see comment above */);
-    }
-
-    Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n",
-              pStream->u8SD,
-              HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), HDA_STREAM_REG(pThis, CBL, pStream->u8SD), HDA_STREAM_REG(pThis, LVI, pStream->u8SD)));
+        RTCircBufReleaseReadBlock(pStreamR3->State.pCircBuf, 0 /* Don't advance read pointer -- see comment above */);
+    }
+
+    Log2Func(("[SD%RU8] LPIB=%RU32, CBL=%RU32, LVI=%RU32\n", pStreamR3->u8SD, HDA_STREAM_REG(pThis, LPIB, pStreamShared->u8SD),
+              HDA_STREAM_REG(pThis, CBL, pStreamShared->u8SD), HDA_STREAM_REG(pThis, LVI, pStreamShared->u8SD)));
 
 #ifdef LOG_ENABLED
-    hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+    hdaR3BDLEDumpAll(pDevIns, pThis, pStreamShared->u64BDLBase, pStreamShared->u16LVI + 1);
 #endif
 
@@ -3510 +3474 @@
 static DECLCALLBACK(int) hdaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
 {
-    PHDASTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
+    PHDASTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    PCPDMDEVHLPR3 pHlp    = pDevIns->pHlpR3;
 
     /* Save Codec nodes states. */
-    hdaCodecSaveState(pDevIns, pThis->pCodec, pSSM);
+    hdaCodecSaveState(pDevIns, pThisCC->pCodec, pSSM);
 
     /* Save MMIO registers. */
@@ -3530 +3495 @@
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
     {
-        int rc = hdaR3SaveStream(pDevIns, pSSM, &pThis->aStreams[i]);
+        int rc = hdaR3SaveStream(pDevIns, pSSM, &pThis->aStreams[i], &pThisCC->aStreams[i]);
         AssertRCReturn(rc, rc);
     }
@@ -3541 +3506 @@
  *
  * @param   pDevIns             The device instance.
- * @param   pThis               Pointer to HDA state.
- */
-static int hdaR3LoadExecPost(PPDMDEVINS pDevIns, PHDASTATE pThis)
-{
-    int rc = VINF_SUCCESS;
+ * @param   pThis               Pointer to the shared HDA state.
+ * @param   pThisCC             Pointer to the ring-3 HDA state.
+ */
+static int hdaR3LoadExecPost(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC)
+{
+    int rc = VINF_SUCCESS; /** @todo r=bird: Really, what's the point of this? */
 
     /*
      * Enable all previously active streams.
      */
-    for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
-    {
-        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, i);
-        if (pStream)
-        {
+    for (size_t i = 0; i < HDA_MAX_STREAMS; i++)
+    {
+        PHDASTREAM pStreamShared = &pThis->aStreams[i];
+
+        bool fActive = RT_BOOL(HDA_STREAM_REG(pThis, CTL, i) & HDA_SDCTL_RUN);
+        if (fActive)
+        {
+            PHDASTREAMR3 pStreamR3 = &pThisCC->aStreams[i];
+
             int rc2;
-
-            bool fActive = RT_BOOL(HDA_STREAM_REG(pThis, CTL, i) & HDA_SDCTL_RUN);
-            if (fActive)
-            {
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-                /* Make sure to also create the async I/O thread before actually enabling the stream. */
-                rc2 = hdaR3StreamAsyncIOCreate(pStream);
-                AssertRC(rc2);
-
-                /* ... and enabling it. */
-                hdaR3StreamAsyncIOEnable(pStream, true /* fEnable */);
+            /* Make sure to also create the async I/O thread before actually enabling the stream. */
+            rc2 = hdaR3StreamAsyncIOCreate(pStreamR3);
+            AssertRC(rc2);
+
+            /* ... and enabling it. */
+            hdaR3StreamAsyncIOEnable(pStreamR3, true /* fEnable */);
 #endif
-                /* Resume the stream's period. */
-                hdaR3StreamPeriodResume(&pStream->State.Period);
-
-                /* (Re-)enable the stream. */
-                rc2 = hdaR3StreamEnable(pStream, true /* fEnable */);
-                AssertRC(rc2);
-
-                /* Add the stream to the device setup. */
-                rc2 = hdaR3AddStream(pThis, &pStream->State.Cfg);
-                AssertRC(rc2);
+            /* Resume the stream's period. */
+            hdaR3StreamPeriodResume(&pStreamShared->State.Period);
+
+            /* (Re-)enable the stream. */
+            rc2 = hdaR3StreamEnable(pStreamShared, pStreamR3, true /* fEnable */);
+            AssertRC(rc2);
+
+            /* Add the stream to the device setup. */
+            rc2 = hdaR3AddStream(pThisCC, &pStreamShared->State.Cfg);
+            AssertRC(rc2);
 
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
-                /* (Re-)install the DMA handler. */
-                hdaR3StreamRegisterDMAHandlers(pThis, pStream);
+            /* (Re-)install the DMA handler. */
+            hdaR3StreamRegisterDMAHandlers(pThis, pStreamShared);
 #endif
-                if (hdaR3StreamTransferIsScheduled(pStream, PDMDevHlpTimerGet(pDevIns, pStream->hTimer)))
-                    hdaR3TimerSet(pDevIns, pStream, hdaR3StreamTransferGetNext(pStream), true /*fForce*/, 0 /*tsNow*/);
-
-                /* Also keep track of the currently active streams. */
-                pThis->cStreamsActive++;
-            }
+            if (hdaR3StreamTransferIsScheduled(pStreamShared, PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer)))
+                hdaR3TimerSet(pDevIns, pStreamShared, hdaR3StreamTransferGetNext(pStreamShared), true /*fForce*/, 0 /*tsNow*/);
+
+            /* Also keep track of the currently active streams. */
+            pThisCC->cStreamsActive++;
         }
     }
@@ -3601 +3566 @@
  *
  * @param   pDevIns     The device instance.
- * @param   pThis       Pointer to HDA state.
+ * @param   pThis       Pointer to the shared HDA state.
+ * @param   pThisCC     Pointer to the ring-3 HDA state.
  * @param   pSSM        Pointer to SSM handle.
  * @param   uVersion    Saved state version to load.
  */
-static int hdaR3LoadExecLegacy(PPDMDEVINS pDevIns, PHDASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion)
+static int hdaR3LoadExecLegacy(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC, PSSMHANDLE pSSM, uint32_t uVersion)
 {
     PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
@@ -3694 +3660 @@
 
             /* Output */
-            PHDASTREAM pStream = &pThis->aStreams[4];
-            rc = hdaR3StreamInit(pDevIns, pStream, 4 /* Stream descriptor, hardcoded */);
+            PHDASTREAM pStreamShared = &pThis->aStreams[4];
+            rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, &pThisCC->aStreams[4], 4 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
-            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
+            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE, sizeof(pStreamShared->State.BDLE),
                                          0 /* fFlags */, g_aSSMStreamBdleFields1234, pDevIns);
             AssertRCReturn(rc, rc);
-            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
+            pStreamShared->State.uCurBDLE = pStreamShared->State.BDLE.State.u32BDLIndex;
 
             /* Microphone-In */
-            pStream = &pThis->aStreams[2];
-            rc = hdaR3StreamInit(pDevIns, pStream, 2 /* Stream descriptor, hardcoded */);
+            pStreamShared = &pThis->aStreams[2];
+            rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, &pThisCC->aStreams[2], 2 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
-            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
+            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE, sizeof(pStreamShared->State.BDLE),
                                          0 /* fFlags */, g_aSSMStreamBdleFields1234, pDevIns);
             AssertRCReturn(rc, rc);
-            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
+            pStreamShared->State.uCurBDLE = pStreamShared->State.BDLE.State.u32BDLIndex;
 
             /* Line-In */
-            pStream = &pThis->aStreams[0];
-            rc = hdaR3StreamInit(pDevIns, pStream, 0 /* Stream descriptor, hardcoded */);
+            pStreamShared = &pThis->aStreams[0];
+            rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, &pThisCC->aStreams[0], 0 /* Stream descriptor, hardcoded */);
             AssertRCReturn(rc, rc);
-            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE, sizeof(pStream->State.BDLE),
+            rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE, sizeof(pStreamShared->State.BDLE),
                                          0 /* fFlags */, g_aSSMStreamBdleFields1234, pDevIns);
             AssertRCReturn(rc, rc);
-            pStream->State.uCurBDLE = pStream->State.BDLE.State.u32BDLIndex;
+            pStreamShared->State.uCurBDLE = pStreamShared->State.BDLE.State.u32BDLIndex;
             break;
         }
@@ -3743 +3709 @@
                 AssertRCReturn(rc, rc);
 
-                HDASTREAM  StreamDummy;
-                PHDASTREAM pStream = hdaGetStreamFromSD(pThis, idStream);
-                if (!pStream)
-                {
-                    pStream = &StreamDummy;
-                    LogRel2(("HDA: Warning: Stream ID=%RU32 not supported, skipping loading it ...\n", idStream));
-                }
-
-                rc = hdaR3StreamInit(pDevIns, pStream, idStream);
+                HDASTREAM    StreamDummyShared;
+                HDASTREAMR3  StreamDummyR3;
+                PHDASTREAM   pStreamShared = idStream < RT_ELEMENTS(pThis->aStreams) ? &pThis->aStreams[idStream] : &StreamDummyShared;
+                PHDASTREAMR3 pStreamR3     = idStream < RT_ELEMENTS(pThisCC->aStreams) ? &pThisCC->aStreams[idStream] : &StreamDummyR3;
+                AssertLogRelMsgStmt(idStream < RT_ELEMENTS(pThisCC->aStreams),
+                                    ("HDA stream ID=%RU8 not supported, skipping loadingit ...\n", idStream),
+                                    RT_ZERO(StreamDummyShared); RT_ZERO(StreamDummyR3));
+
+                rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, pStreamR3, idStream);
                 if (RT_FAILURE(rc))
                 {
-                    LogRel(("HDA: Stream #%RU32: Initialization of stream %RU8 failed, rc=%Rrc\n", i, idStream, rc));
+                    LogRel(("HDA: Stream #%RU32: Setting up of stream %RU8 failed, rc=%Rrc\n", i, idStream, rc));
                     break;
                 }
@@ -3779 +3745 @@
                     rc = pHlp->pfnSSMGetStructEx(pSSM, &Tmp, sizeof(Tmp), 0 /* fFlags */, g_aV5State1Fields, NULL);
                     AssertRCReturn(rc, rc);
-                    pStream->State.uCurBDLE = Tmp.uCurBDLE;
+                    pStreamShared->State.uCurBDLE = Tmp.uCurBDLE;
 
                     for (uint16_t a = 0; a < Tmp.cBLDEs; a++)
@@ -3792 +3758 @@
                         rc = pHlp->pfnSSMGetStructEx(pSSM, &Tmp, sizeof(Tmp), 0 /* fFlags */, g_aV5State2Fields, NULL);
                         AssertRCReturn(rc, rc);
-                        if (Tmp.u32BDLEIndex == pStream->State.uCurBDLE)
+                        if (Tmp.u32BDLEIndex == pStreamShared->State.uCurBDLE)
                         {
-                            pStream->State.BDLE.State.cbBelowFIFOW = Tmp.cbBelowFIFOW;
-                            pStream->State.BDLE.State.u32BufOff    = Tmp.u32BufOff;
+                            pStreamShared->State.BDLE.State.cbBelowFIFOW = Tmp.cbBelowFIFOW;
+                            pStreamShared->State.BDLE.State.u32BufOff    = Tmp.u32BufOff;
                         }
                     }
@@ -3801 +3767 @@
                 else
                 {
-                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
+                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State, sizeof(HDASTREAMSTATE),
                                                  0 /* fFlags */, g_aSSMStreamStateFields6, NULL);
                     AssertRCReturn(rc, rc);
 
-                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(pStream->State.BDLE.Desc),
+                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE.Desc, sizeof(pStreamShared->State.BDLE.Desc),
                                                  0 /* fFlags */, g_aSSMBDLEDescFields6, pDevIns);
                     AssertRCReturn(rc, rc);
 
-                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
+                    rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE.State, sizeof(HDABDLESTATE),
                                                  0 /* fFlags */, g_aSSMBDLEStateFields6, NULL);
                     AssertRCReturn(rc, rc);
@@ -3816 +3782 @@
                               HDA_STREAM_REG(pThis, CBL, idStream), HDA_STREAM_REG(pThis, LVI, idStream)));
 #ifdef LOG_ENABLED
-                    hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+                    hdaR3BDLEDumpAll(pDevIns, pThis, pStreamShared->u64BDLBase, pStreamShared->u16LVI + 1);
 #endif
                 }
@@ -3833 +3799 @@
 static DECLCALLBACK(int) hdaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
-    PHDASTATE     pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
+    PHDASTATE     pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3   pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+    PCPDMDEVHLPR3 pHlp    = pDevIns->pHlpR3;
 
     Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
@@ -3843 +3810 @@
      * Load Codec nodes states.
      */
-    int rc = hdaCodecLoadState(pDevIns, pThis->pCodec, pSSM, uVersion);
+    int rc = hdaCodecLoadState(pDevIns, pThisCC->pCodec, pSSM, uVersion);
     if (RT_FAILURE(rc))
     {
@@ -3852 +3819 @@
     if (uVersion <= HDA_SAVED_STATE_VERSION_6) /* Handle older saved states? */
     {
-        rc = hdaR3LoadExecLegacy(pDevIns, pThis, pSSM, uVersion);
+        rc = hdaR3LoadExecLegacy(pDevIns, pThis, pThisCC, pSSM, uVersion);
         if (RT_SUCCESS(rc))
-            rc = hdaR3LoadExecPost(pDevIns, pThis);
+            rc = hdaR3LoadExecPost(pDevIns, pThis, pThisCC);
         return rc;
     }
@@ -3918 +3885 @@
         AssertRCReturn(rc, rc);
 
-        PHDASTREAM pStream = hdaGetStreamFromSD(pThis, idStream);
-        HDASTREAM  StreamDummy;
-
-        if (!pStream)
-        {
-            RT_ZERO(StreamDummy);
-            pStream = &StreamDummy;
-            LogRel2(("HDA: Warning: Loading of stream #%RU8 not supported, skipping to load ...\n", idStream));
-        }
-
-        rc = hdaR3StreamInit(pDevIns, pStream, idStream);
+        HDASTREAM    StreamDummyShared;
+        HDASTREAMR3  StreamDummyR3;
+        PHDASTREAM   pStreamShared = idStream < RT_ELEMENTS(pThis->aStreams) ? &pThis->aStreams[idStream] : &StreamDummyShared;
+        PHDASTREAMR3 pStreamR3     = idStream < RT_ELEMENTS(pThisCC->aStreams) ? &pThisCC->aStreams[idStream] : &StreamDummyR3;
+        AssertLogRelMsgStmt(idStream < RT_ELEMENTS(pThisCC->aStreams),
+                            ("HDA stream ID=%RU8 not supported, skipping loadingit ...\n", idStream),
+                            RT_ZERO(StreamDummyShared); RT_ZERO(StreamDummyR3));
+
+        rc = hdaR3StreamSetUp(pDevIns, pThis, pStreamShared, pStreamR3, idStream);
         if (RT_FAILURE(rc))
         {
-            LogRel(("HDA: Stream #%RU8: Loading initialization failed, rc=%Rrc\n", idStream, rc));
+            LogRel(("HDA: Stream #%RU8: Setting up failed, rc=%Rrc\n", idStream, rc));
             /* Continue. */
         }
 
-        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State, sizeof(HDASTREAMSTATE),
+        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State, sizeof(HDASTREAMSTATE),
                                      0 /* fFlags */, g_aSSMStreamStateFields7, NULL);
         AssertRCReturn(rc, rc);
@@ -3942 +3907 @@
          * Load BDLEs (Buffer Descriptor List Entries) and DMA counters.
          */
-        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.Desc, sizeof(HDABDLEDESC),
+        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE.Desc, sizeof(HDABDLEDESC),
                                      0 /* fFlags */, g_aSSMBDLEDescFields7, NULL);
         AssertRCReturn(rc, rc);
 
-        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.BDLE.State, sizeof(HDABDLESTATE),
+        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.BDLE.State, sizeof(HDABDLESTATE),
                                      0 /* fFlags */, g_aSSMBDLEStateFields7, NULL);
         AssertRCReturn(rc, rc);
 
-        Log2Func(("[SD%RU8] %R[bdle]\n", pStream->u8SD, &pStream->State.BDLE));
+        Log2Func(("[SD%RU8] %R[bdle]\n", pStreamShared->u8SD, &pStreamShared->State.BDLE));
 
         /*
          * Load period state.
          */
-        hdaR3StreamPeriodInit(&pStream->State.Period, pStream->u8SD, pStream->u16LVI, pStream->u32CBL, &pStream->State.Cfg);
-
-        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStream->State.Period, sizeof(HDASTREAMPERIOD),
+        hdaR3StreamPeriodInit(&pStreamShared->State.Period, pStreamShared->u8SD, pStreamShared->u16LVI,
+                              pStreamShared->u32CBL, &pStreamShared->State.Cfg);
+
+        rc = pHlp->pfnSSMGetStructEx(pSSM, &pStreamShared->State.Period, sizeof(pStreamShared->State.Period),
                                      0 /* fFlags */, g_aSSMStreamPeriodFields7, NULL);
         AssertRCReturn(rc, rc);
@@ -3983 +3949 @@
 
             /* Do we need to cre-create the circular buffer do fit the data size? */
-            if (   pStream->State.pCircBuf
-                && cbCircBufSize != (uint32_t)RTCircBufSize(pStream->State.pCircBuf))
+            if (   pStreamR3->State.pCircBuf
+                && cbCircBufSize != (uint32_t)RTCircBufSize(pStreamR3->State.pCircBuf))
             {
-                RTCircBufDestroy(pStream->State.pCircBuf);
-                pStream->State.pCircBuf = NULL;
+                RTCircBufDestroy(pStreamR3->State.pCircBuf);
+                pStreamR3->State.pCircBuf = NULL;
             }
 
-            rc = RTCircBufCreate(&pStream->State.pCircBuf, cbCircBufSize);
+            rc = RTCircBufCreate(&pStreamR3->State.pCircBuf, cbCircBufSize);
             AssertRCReturn(rc, rc);
 
@@ -3997 +3963 @@
                 void  *pvBuf;
                 size_t cbBuf;
-                RTCircBufAcquireWriteBlock(pStream->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
+                RTCircBufAcquireWriteBlock(pStreamR3->State.pCircBuf, cbCircBufUsed, &pvBuf, &cbBuf);
 
                 AssertLogRelMsgReturn(cbBuf == cbCircBufUsed, ("cbBuf=%zu cbCircBufUsed=%zu\n", cbBuf, cbCircBufUsed),
@@ -4004 +3970 @@
                 AssertRCReturn(rc, rc);
 
-                RTCircBufReleaseWriteBlock(pStream->State.pCircBuf, cbBuf);
+                RTCircBufReleaseWriteBlock(pStreamR3->State.pCircBuf, cbBuf);
 
                 Assert(cbBuf == cbCircBufUsed);
@@ -4013 +3979 @@
                   HDA_STREAM_REG(pThis, CBL, idStream), HDA_STREAM_REG(pThis, LVI, idStream)));
 #ifdef LOG_ENABLED
-        hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+        hdaR3BDLEDumpAll(pDevIns, pThis, pStreamShared->u64BDLBase, pStreamShared->u16LVI + 1);
 #endif
         /** @todo (Re-)initialize active periods? */
@@ -4019 +3985 @@
     } /* for cStreams */
 
-    rc = hdaR3LoadExecPost(pDevIns, pThis);
+    rc = hdaR3LoadExecPost(pDevIns, pThis, pThisCC);
     AssertRC(rc);
 
@@ -4170 +4136 @@
 }
 
-static void hdaR3DbgPrintBDLE(PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
+static void hdaR3DbgPrintBDLE(PPDMDEVINS pDevIns, PHDASTATE pThis, PCDBGFINFOHLP pHlp, int iIdx)
 {
     Assert(   pThis
@@ -4197 +4163 @@
     {
         HDABDLEDESC bd;
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BaseDMA + i * sizeof(HDABDLEDESC), &bd, sizeof(bd));
+        PDMDevHlpPhysRead(pDevIns, u64BaseDMA + i * sizeof(HDABDLEDESC), &bd, sizeof(bd));
 
         pHlp->pfnPrintf(pHlp, "\t\t%s #%03d BDLE(adr:0x%llx, size:%RU32, ioc:%RTbool)\n",
@@ -4220 +4186 @@
     {
         uint32_t uDMACnt;
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
+        PDMDevHlpPhysRead(pDevIns, (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
                           &uDMACnt, sizeof(uDMACnt));
 
@@ -4256 +4222 @@
     int         iHdaStreamdex = hdaR3DbgLookupStrmIdx(pThis, pszArgs);
     if (iHdaStreamdex != -1)
-        hdaR3DbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
+        hdaR3DbgPrintBDLE(pDevIns, pThis, pHlp, iHdaStreamdex);
     else
         for (iHdaStreamdex = 0; iHdaStreamdex < HDA_MAX_STREAMS; ++iHdaStreamdex)
-            hdaR3DbgPrintBDLE(pThis, pHlp, iHdaStreamdex);
+            hdaR3DbgPrintBDLE(pDevIns, pThis, pHlp, iHdaStreamdex);
 }
 
@@ -4267 +4233 @@
 static DECLCALLBACK(void) hdaR3DbgInfoCodecNodes(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-
-    if (pThis->pCodec->pfnDbgListNodes)
-        pThis->pCodec->pfnDbgListNodes(pThis->pCodec, pHlp, pszArgs);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+
+    if (pThisCC->pCodec->pfnDbgListNodes)
+        pThisCC->pCodec->pfnDbgListNodes(pThisCC->pCodec, pHlp, pszArgs);
     else
         pHlp->pfnPrintf(pHlp, "Codec implementation doesn't provide corresponding callback\n");
@@ -4280 +4246 @@
 static DECLCALLBACK(void) hdaR3DbgInfoCodecSelector(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-
-    if (pThis->pCodec->pfnDbgSelector)
-        pThis->pCodec->pfnDbgSelector(pThis->pCodec, pHlp, pszArgs);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+
+    if (pThisCC->pCodec->pfnDbgSelector)
+        pThisCC->pCodec->pfnDbgSelector(pThisCC->pCodec, pHlp, pszArgs);
     else
         pHlp->pfnPrintf(pHlp, "Codec implementation doesn't provide corresponding callback\n");
@@ -4293 +4259 @@
 static DECLCALLBACK(void) hdaR3DbgInfoMixer(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
-
-    if (pThis->pMixer)
-        AudioMixerDebug(pThis->pMixer, pHlp, pszArgs);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
+
+    if (pThisCC->pMixer)
+        AudioMixerDebug(pThisCC->pMixer, pHlp, pszArgs);
     else
         pHlp->pfnPrintf(pHlp, "Mixer not available\n");
@@ -4311 +4277 @@
 static DECLCALLBACK(void *) hdaR3QueryInterface(struct PDMIBASE *pInterface, const char *pszIID)
 {
-    PHDASTATE pThis = RT_FROM_MEMBER(pInterface, HDASTATE, IBase);
-    Assert(&pThis->IBase == pInterface);
-
-    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
+    PHDASTATER3 pThisCC = RT_FROM_MEMBER(pInterface, HDASTATER3, IBase);
+
+    PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThisCC->IBase);
     return NULL;
 }
@@ -4331 +4296 @@
  *
  * @returns VBox status code.
- * @param   pThis       HDA state.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared HDA device state.
+ * @param   pThisR3     The ring-3 HDA device state.
  * @param   uLUN        The logical unit which is being detached.
  * @param   fFlags      Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
  * @param   ppDrv       Attached driver instance on success. Optional.
  */
-static int hdaR3AttachInternal(PHDASTATE pThis, unsigned uLUN, uint32_t fFlags, PHDADRIVER *ppDrv)
+static int hdaR3AttachInternal(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC, unsigned uLUN, uint32_t fFlags, PHDADRIVER *ppDrv)
 {
     RT_NOREF(fFlags);
@@ -4348 +4315 @@
 
     PPDMIBASE pDrvBase;
-    int rc = PDMDevHlpDriverAttach(pThis->pDevInsR3, uLUN,
-                                   &pThis->IBase, &pDrvBase, pszDesc);
+    int rc = PDMDevHlpDriverAttach(pDevIns, uLUN, &pThisCC->IBase, &pDrvBase, pszDesc);
     if (RT_SUCCESS(rc))
     {
@@ -4355 +4321 @@
         if (pDrv)
         {
-            pDrv->pDrvBase   = pDrvBase;
-            pDrv->pConnector = PDMIBASE_QUERY_INTERFACE(pDrvBase, PDMIAUDIOCONNECTOR);
+            pDrv->pDrvBase          = pDrvBase;
+            pDrv->pHDAStateShared   = pThis;
+            pDrv->pHDAStateR3       = pThisCC;
+            pDrv->uLUN              = uLUN;
+            pDrv->pConnector        = PDMIBASE_QUERY_INTERFACE(pDrvBase, PDMIAUDIOCONNECTOR);
             AssertMsg(pDrv->pConnector != NULL, ("Configuration error: LUN#%u has no host audio interface, rc=%Rrc\n", uLUN, rc));
-            pDrv->pHDAState  = pThis;
-            pDrv->uLUN       = uLUN;
 
             /*
@@ -4373 +4340 @@
             if (!pDrv->fAttached)
             {
-                RTListAppend(&pThis->lstDrv, &pDrv->Node);
+                RTListAppend(&pThisCC->lstDrv, &pDrv->Node);
                 pDrv->fAttached = true;
             }
@@ -4404 +4371 @@
  *
  * @returns VBox status code.
- * @param   pThis       HDA state.
+ * @param   pThisR3     The ring-3 HDA device state.
  * @param   pDrv        Driver to detach from device.
  * @param   fFlags      Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
  */
-static int hdaR3DetachInternal(PHDASTATE pThis, PHDADRIVER pDrv, uint32_t fFlags)
+static int hdaR3DetachInternal(PHDASTATER3 pThisCC, PHDADRIVER pDrv, uint32_t fFlags)
 {
     RT_NOREF(fFlags);
@@ -4414 +4381 @@
     /* First, remove the driver from our list and destory it's associated streams.
      * This also will un-set the driver as a recording source (if associated). */
-    hdaR3MixerRemoveDrv(pThis, pDrv);
+    hdaR3MixerRemoveDrv(pThisCC, pDrv);
 
     /* Next, search backwards for a capable (attached) driver which now will be the
      * new recording source. */
     PHDADRIVER pDrvCur;
-    RTListForEachReverse(&pThis->lstDrv, pDrvCur, HDADRIVER, Node)
+    RTListForEachReverse(&pThisCC->lstDrv, pDrvCur, HDADRIVER, Node)
     {
         if (!pDrvCur->pConnector)
@@ -4435 +4402 @@
             && pDrvStrm->pMixStrm)
         {
-            rc2 = AudioMixerSinkSetRecordingSource(pThis->SinkMicIn.pMixSink, pDrvStrm->pMixStrm);
+            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->SinkMicIn.pMixSink, pDrvStrm->pMixStrm);
             if (RT_SUCCESS(rc2))
                 LogRel2(("HDA: Set new recording source for 'Mic In' to '%s'\n", Cfg.szName));
@@ -4444 +4411 @@
             && pDrvStrm->pMixStrm)
         {
-            rc2 = AudioMixerSinkSetRecordingSource(pThis->SinkLineIn.pMixSink, pDrvStrm->pMixStrm);
+            rc2 = AudioMixerSinkSetRecordingSource(pThisCC->SinkLineIn.pMixSink, pDrvStrm->pMixStrm);
             if (RT_SUCCESS(rc2))
                 LogRel2(("HDA: Set new recording source for 'Line In' to '%s'\n", Cfg.szName));
@@ -4459 +4426 @@
 static DECLCALLBACK(int) hdaR3Attach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
 
     DEVHDA_LOCK_RETURN(pDevIns, pThis, VERR_IGNORED);
@@ -4466 +4434 @@
 
     PHDADRIVER pDrv;
-    int rc2 = hdaR3AttachInternal(pThis, uLUN, fFlags, &pDrv);
+    int rc2 = hdaR3AttachInternal(pDevIns, pThis, pThisCC, uLUN, fFlags, &pDrv);
     if (RT_SUCCESS(rc2))
-        rc2 = hdaR3MixerAddDrv(pThis, pDrv);
+        rc2 = hdaR3MixerAddDrv(pThisCC, pDrv);
 
     if (RT_FAILURE(rc2))
@@ -4483 +4451 @@
 static DECLCALLBACK(void) hdaR3Detach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
 
     DEVHDA_LOCK(pDevIns, pThis);
@@ -4490 +4459 @@
 
     PHDADRIVER pDrv, pDrvNext;
-    RTListForEachSafe(&pThis->lstDrv, pDrv, pDrvNext, HDADRIVER, Node)
+    RTListForEachSafe(&pThisCC->lstDrv, pDrv, pDrvNext, HDADRIVER, Node)
     {
         if (pDrv->uLUN == uLUN)
         {
-            int rc2 = hdaR3DetachInternal(pThis, pDrv, fFlags);
+            int rc2 = hdaR3DetachInternal(pThisCC, pDrv, fFlags);
             if (RT_SUCCESS(rc2))
             {
@@ -4515 +4484 @@
 static DECLCALLBACK(void) hdaR3PowerOff(PPDMDEVINS pDevIns)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
 
     DEVHDA_LOCK_RETURN_VOID(pDevIns, pThis);
@@ -4522 +4492 @@
 
     /* Ditto goes for the codec, which in turn uses the mixer. */
-    hdaCodecPowerOff(pThis->pCodec);
+    hdaCodecPowerOff(pThisCC->pCodec);
 
     /*
@@ -4529 +4499 @@
      *       PDM audio streams it maintains.
      */
-    if (pThis->pMixer)
-    {
-        AudioMixerDestroy(pThis->pMixer);
-        pThis->pMixer = NULL;
+    if (pThisCC->pMixer)
+    {
+        AudioMixerDestroy(pThisCC->pMixer);
+        pThisCC->pMixer = NULL;
     }
 
@@ -4542 +4512 @@
  *
  * @returns VBox status code.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared HDA device state.
+ * @param   pThisCC     The ring-3 HDA device state.
  * @param   pThis       Device instance.
  * @param   iLun        The logical unit which is being replaced.
  */
-static int hdaR3ReconfigLunWithNullAudio(PHDASTATE pThis, unsigned iLun)
-{
-    int rc = PDMDevHlpDriverReconfigure2(pThis->pDevInsR3, iLun, "AUDIO", "NullAudio");
+static int hdaR3ReconfigLunWithNullAudio(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC, unsigned iLun)
+{
+    int rc = PDMDevHlpDriverReconfigure2(pDevIns, iLun, "AUDIO", "NullAudio");
     if (RT_SUCCESS(rc))
-        rc = hdaR3AttachInternal(pThis, iLun, 0 /* fFlags */, NULL /* ppDrv */);
+        rc = hdaR3AttachInternal(pDevIns, pThis, pThisCC, iLun, 0 /* fFlags */, NULL /* ppDrv */);
     LogFunc(("pThis=%p, iLun=%u, rc=%Rrc\n", pThis, iLun, rc));
     return rc;
@@ -4560 +4533 @@
 static DECLCALLBACK(void) hdaR3Reset(PPDMDEVINS pDevIns)
 {
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
 
     LogFlowFuncEnter();
@@ -4572 +4546 @@
     HDA_REG(pThis, WAKEEN)  = 0x0;
 
-    hdaR3GCTLReset(pThis);
+    hdaR3GCTLReset(pDevIns, pThis, pThisCC);
 
     /* Indicate that HDA is not in reset. The firmware is supposed to (un)reset HDA,
@@ -4589 +4563 @@
 {
     PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns); /* this shall come first */
-    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3 pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
     DEVHDA_LOCK(pDevIns, pThis); /** @todo r=bird: this will fail on early constructor failure. */
 
     PHDADRIVER pDrv;
-    while (!RTListIsEmpty(&pThis->lstDrv))
-    {
-        pDrv = RTListGetFirst(&pThis->lstDrv, HDADRIVER, Node);
+    while (!RTListIsEmpty(&pThisCC->lstDrv))
+    {
+        pDrv = RTListGetFirst(&pThisCC->lstDrv, HDADRIVER, Node);
 
         RTListNodeRemove(&pDrv->Node);
@@ -4601 +4576 @@
     }
 
-    if (pThis->pCodec)
-    {
-        hdaCodecDestruct(pThis->pCodec);
-
-        RTMemFree(pThis->pCodec);
-        pThis->pCodec = NULL;
-    }
-
-    RTMemFree(pThis->pu32CorbBuf);
-    pThis->pu32CorbBuf = NULL;
-
-    RTMemFree(pThis->pu64RirbBuf);
-    pThis->pu64RirbBuf = NULL;
+    if (pThisCC->pCodec)
+    {
+        hdaCodecDestruct(pThisCC->pCodec);
+
+        RTMemFree(pThisCC->pCodec);
+        pThisCC->pCodec = NULL;
+    }
 
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
-        hdaR3StreamDestroy(&pThis->aStreams[i]);
+        hdaR3StreamDestroy(&pThis->aStreams[i], &pThisCC->aStreams[i]);
 
     DEVHDA_UNLOCK(pDevIns, pThis);
@@ -4630 +4599 @@
     PDMDEV_CHECK_VERSIONS_RETURN(pDevIns); /* this shall come first */
     PHDASTATE       pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
+    PHDASTATER3     pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PHDASTATER3);
     PCPDMDEVHLPR3   pHlp    = pDevIns->pHlpR3;
     Assert(iInstance == 0); RT_NOREF(iInstance);
@@ -4637 +4607 @@
      */
     pThis->uAlignmentCheckMagic = HDASTATE_ALIGNMENT_CHECK_MAGIC;
-    RTListInit(&pThis->lstDrv);
+    RTListInit(&pThisCC->lstDrv);
+    pThis->cbCorbBuf            = HDA_CORB_SIZE * HDA_CORB_ELEMENT_SIZE;
+    pThis->cbRirbBuf            = HDA_RIRB_SIZE * HDA_RIRB_ELEMENT_SIZE;
+
     /** @todo r=bird: There are probably other things which should be
      *        initialized here before we start failing. */
@@ -4670 +4643 @@
         LogRel(("HDA: Using custom position adjustment (%RU16 audio frames)\n", pThis->cPosAdjustFrames));
 
-    rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "DebugEnabled", &pThis->Dbg.fEnabled, false);
+    rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "DebugEnabled", &pThisCC->Dbg.fEnabled, false);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
                                 N_("HDA configuration error: failed to read debugging enabled flag as boolean"));
 
-    rc = pHlp->pfnCFGMQueryStringDef(pCfg, "DebugPathOut", pThis->Dbg.szOutPath, sizeof(pThis->Dbg.szOutPath),
+    rc = pHlp->pfnCFGMQueryStringDef(pCfg, "DebugPathOut", pThisCC->Dbg.szOutPath, sizeof(pThisCC->Dbg.szOutPath),
                                      VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH);
     if (RT_FAILURE(rc))
@@ -4681 +4654 @@
                                 N_("HDA configuration error: failed to read debugging output path flag as string"));
 
-    if (pThis->Dbg.fEnabled)
-        LogRel2(("HDA: Debug output will be saved to '%s'\n", pThis->Dbg.szOutPath));
+    if (pThisCC->Dbg.fEnabled)
+        LogRel2(("HDA: Debug output will be saved to '%s'\n", pThisCC->Dbg.szOutPath));
 
     /*
@@ -4698 +4671 @@
      * Initialize data (most of it anyway).
      */
-    pThis->pDevInsR3                = pDevIns;
+    pThisCC->pDevIns                  = pDevIns;
     /* IBase */
-    pThis->IBase.pfnQueryInterface  = hdaR3QueryInterface;
+    pThisCC->IBase.pfnQueryInterface  = hdaR3QueryInterface;
 
     /* PCI Device */
@@ -4827 +4800 @@
         AssertBreak(iLun < UINT8_MAX);
         LogFunc(("Trying to attach driver for LUN#%u ...\n", iLun));
-        rc = hdaR3AttachInternal(pThis, iLun, 0 /* fFlags */, NULL /* ppDrv */);
+        rc = hdaR3AttachInternal(pDevIns, pThis, pThisCC, iLun, 0 /* fFlags */, NULL /* ppDrv */);
         if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
         {
@@ -4835 +4808 @@
         if (rc == VERR_AUDIO_BACKEND_INIT_FAILED)
         {
-            hdaR3ReconfigLunWithNullAudio(pThis, iLun); /* Pretend attaching to the NULL audio backend will never fail. */
+            hdaR3ReconfigLunWithNullAudio(pDevIns, pThis, pThisCC, iLun); /* Pretend attaching to the NULL audio backend will never fail. */
             PDMDevHlpVMSetRuntimeError(pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
                                        N_("Host audio backend initialization has failed. Selecting the NULL audio backend with the consequence that no sound is audible"));
@@ -4846 +4819 @@
      * Create the mixer.
      */
-    rc = AudioMixerCreate("HDA Mixer", 0 /* uFlags */, &pThis->pMixer);
+    rc = AudioMixerCreate("HDA Mixer", 0 /* uFlags */, &pThisCC->pMixer);
     AssertRCReturn(rc, rc);
 
@@ -4853 +4826 @@
      */
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Front", AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Playback] Front", AUDMIXSINKDIR_OUTPUT, &pThisCC->SinkFront.pMixSink);
     AssertRCReturn(rc, rc);
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Center / Subwoofer", AUDMIXSINKDIR_OUTPUT, &pThis->SinkCenterLFE.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Playback] Center / Subwoofer", AUDMIXSINKDIR_OUTPUT, &pThisCC->SinkCenterLFE.pMixSink);
     AssertRCReturn(rc, rc);
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] Rear", AUDMIXSINKDIR_OUTPUT, &pThis->SinkRear.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Playback] Rear", AUDMIXSINKDIR_OUTPUT, &pThisCC->SinkRear.pMixSink);
     AssertRCReturn(rc, rc);
 #else
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Playback] PCM Output", AUDMIXSINKDIR_OUTPUT, &pThis->SinkFront.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Playback] PCM Output", AUDMIXSINKDIR_OUTPUT, &pThisCC->SinkFront.pMixSink);
     AssertRCReturn(rc, rc);
 #endif
@@ -4867 +4840 @@
      * Add mixer input sinks.
      */
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Line In", AUDMIXSINKDIR_INPUT, &pThis->SinkLineIn.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Recording] Line In", AUDMIXSINKDIR_INPUT, &pThisCC->SinkLineIn.pMixSink);
     AssertRCReturn(rc, rc);
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    rc = AudioMixerCreateSink(pThis->pMixer, "[Recording] Microphone In", AUDMIXSINKDIR_INPUT, &pThis->SinkMicIn.pMixSink);
+    rc = AudioMixerCreateSink(pThisCC->pMixer, "[Recording] Microphone In", AUDMIXSINKDIR_INPUT, &pThisCC->SinkMicIn.pMixSink);
     AssertRCReturn(rc, rc);
 #endif
@@ -4876 +4849 @@
     /* There is no master volume control. Set the master to max. */
     PDMAUDIOVOLUME vol = { false, 255, 255 };
-    rc = AudioMixerSetMasterVolume(pThis->pMixer, &vol);
+    rc = AudioMixerSetMasterVolume(pThisCC->pMixer, &vol);
     AssertRCReturn(rc, rc);
 
-    /* Allocate CORB buffer. */
-    pThis->cbCorbBuf   = HDA_CORB_SIZE * HDA_CORB_ELEMENT_SIZE;
-    pThis->pu32CorbBuf = (uint32_t *)RTMemAllocZ(pThis->cbCorbBuf);
-    AssertReturn(pThis->pu32CorbBuf, VERR_NO_MEMORY);
-
-    /* Allocate RIRB buffer. */
-    pThis->cbRirbBuf   = HDA_RIRB_SIZE * HDA_RIRB_ELEMENT_SIZE;
-    pThis->pu64RirbBuf = (uint64_t *)RTMemAllocZ(pThis->cbRirbBuf);
-    AssertReturn(pThis->pu64RirbBuf, VERR_NO_MEMORY);
-
     /* Allocate codec. */
-    pThis->pCodec = (PHDACODEC)RTMemAllocZ(sizeof(HDACODEC));
-    AssertReturn(pThis->pCodec, VERR_NO_MEMORY);
+    PHDACODEC pCodec = (PHDACODEC)RTMemAllocZ(sizeof(HDACODEC));
+    pThisCC->pCodec = pCodec;
+    AssertReturn(pCodec, VERR_NO_MEMORY);
 
     /* Set codec callbacks to this controller. */
-    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. */
+    pCodec->pDevIns                = pDevIns;
+    pCodec->pfnCbMixerAddStream    = hdaR3MixerAddStream;
+    pCodec->pfnCbMixerRemoveStream = hdaR3MixerRemoveStream;
+    pCodec->pfnCbMixerControl      = hdaR3MixerControl;
+    pCodec->pfnCbMixerSetVolume    = hdaR3MixerSetVolume;
 
     /* Construct the codec. */
-    rc = hdaCodecConstruct(pDevIns, pThis->pCodec, 0 /* Codec index */, pCfg);
+    rc = hdaCodecConstruct(pDevIns, pCodec, 0 /* Codec index */, pCfg);
     AssertRCReturn(rc, rc);
 
     /* ICH6 datasheet defines 0 values for SVID and SID (18.1.14-15), which together with values returned for
        verb F20 should provide device/codec recognition. */
-    Assert(pThis->pCodec->u16VendorId);
-    Assert(pThis->pCodec->u16DeviceId);
-    PDMPciDevSetSubSystemVendorId(pPciDev, pThis->pCodec->u16VendorId); /* 2c ro - intel.) */
-    PDMPciDevSetSubSystemId(      pPciDev, pThis->pCodec->u16DeviceId); /* 2e ro. */
+    Assert(pCodec->u16VendorId);
+    Assert(pCodec->u16DeviceId);
+    PDMPciDevSetSubSystemVendorId(pPciDev, pCodec->u16VendorId); /* 2c ro - intel.) */
+    PDMPciDevSetSubSystemId(      pPciDev, pCodec->u16DeviceId); /* 2e ro. */
 
     /*
@@ -4930 +4893 @@
     for (size_t i = 0; i < HDA_MAX_STREAMS; i++)
     {
-        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, &pThis->aStreams[i],
+        rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, hdaR3Timer, (void *)(uintptr_t)i,
                                   TMTIMER_FLAGS_NO_CRIT_SECT, s_apszNames[i], &pThis->aStreams[i].hTimer);
         AssertRCReturn(rc, rc);
@@ -4943 +4906 @@
     for (uint8_t i = 0; i < HDA_MAX_STREAMS; ++i)
     {
-        rc = hdaR3StreamCreate(&pThis->aStreams[i], pThis, i /* u8SD */);
+        rc = hdaR3StreamConstruct(&pThis->aStreams[i], &pThisCC->aStreams[i], pThis, pThisCC, i /* u8SD */);
         AssertRCReturn(rc, rc);
     }
@@ -4952 +4915 @@
      */
     PHDADRIVER pDrv;
-    RTListForEach(&pThis->lstDrv, pDrv, HDADRIVER, Node)
+    RTListForEach(&pThisCC->lstDrv, pDrv, HDADRIVER, Node)
     {
         /*
@@ -5132 +5095 @@
      * Register statistics.
      */
-    PDMDevHlpSTAMRegister(pDevIns, &pThis->StatTimer,            STAMTYPE_PROFILE, "Timer",             STAMUNIT_TICKS_PER_CALL, "Profiling hdaR3Timer.");
     PDMDevHlpSTAMRegister(pDevIns, &pThis->StatIn,               STAMTYPE_PROFILE, "Input",             STAMUNIT_TICKS_PER_CALL, "Profiling input.");
     PDMDevHlpSTAMRegister(pDevIns, &pThis->StatOut,              STAMTYPE_PROFILE, "Output",            STAMUNIT_TICKS_PER_CALL, "Profiling output.");
@@ -5203 +5165 @@
     /* .uSharedVersion = */         42,
     /* .cbInstanceShared = */       sizeof(HDASTATE),
-    /* .cbInstanceCC = */           0,
+    /* .cbInstanceCC = */           CTX_EXPR(sizeof(HDASTATER3), 0, 0),
     /* .cbInstanceRC = */           0,
     /* .cMaxPciDevices = */         1,

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

@@ -36 +36 @@
 
 /**
- * Structure defining an HDA mixer sink.
- * Its purpose is to know which audio mixer sink is bound to
- * which SDn (SDI/SDO) device stream.
- *
- * This is needed in order to handle interleaved streams
- * (that is, multiple channels in one stream) or non-interleaved
- * streams (each channel has a dedicated stream).
+ * HDA mixer sink definition (ring-3).
+ *
+ * Its purpose is to know which audio mixer sink is bound to which SDn
+ * (SDI/SDO) device stream.
+ *
+ * This is needed in order to handle interleaved streams (that is, multiple
+ * channels in one stream) or non-interleaved streams (each channel has a
+ * dedicated stream).
  *
  * This is only known to the actual device emulation level.
@@ -48 +49 @@
 typedef struct HDAMIXERSINK
 {
-    R3PTRTYPE(PHDASTREAM)   pStream;
+    R3PTRTYPE(PHDASTREAM)   pStreamShared;
+    R3PTRTYPE(PHDASTREAMR3) pStreamR3;
     /** Pointer to the actual audio mixer sink. */
     R3PTRTYPE(PAUDMIXSINK)  pMixSink;
-} HDAMIXERSINK, *PHDAMIXERSINK;
-
-/**
- * Mapping a stream tag to an HDA stream.
+} HDAMIXERSINK;
+/** Pointer to an HDA mixer sink definition (ring-3). */
+typedef HDAMIXERSINK *PHDAMIXERSINK;
+
+/**
+ * Mapping a stream tag to an HDA stream (ring-3).
  */
 typedef struct HDATAG
@@ -62 +66 @@
     uint8_t                 Padding[7];
     /** Pointer to associated stream. */
-    R3PTRTYPE(PHDASTREAM) pStream;
+    R3PTRTYPE(PHDASTREAMR3) pStreamR3;
 } HDATAG;
 /** Pointer to a HDA stream tag mapping. */
 typedef HDATAG *PHDATAG;
 
-/** @todo Make STAM values out of this? */
-typedef struct HDASTATEDEBUG
-{
-#ifdef DEBUG
-    /** Timestamp (in ns) of the last timer callback (hdaTimer).
-     * Used to calculate the time actually elapsed between two timer callbacks. */
-    uint64_t                tsTimerLastCalledNs;
-    /** IRQ debugging information. */
-    struct
-    {
-        /** Timestamp (in ns) of last processed (asserted / deasserted) IRQ. */
-        uint64_t            tsProcessedLastNs;
-        /** Timestamp (in ns) of last asserted IRQ. */
-        uint64_t            tsAssertedNs;
-        /** How many IRQs have been asserted already. */
-        uint64_t            cAsserted;
-        /** Accumulated elapsed time (in ns) of all IRQ being asserted. */
-        uint64_t            tsAssertedTotalNs;
-        /** Timestamp (in ns) of last deasserted IRQ. */
-        uint64_t            tsDeassertedNs;
-        /** How many IRQs have been deasserted already. */
-        uint64_t            cDeasserted;
-        /** Accumulated elapsed time (in ns) of all IRQ being deasserted. */
-        uint64_t            tsDeassertedTotalNs;
-    } IRQ;
-#endif
-    /** Whether debugging is enabled or not. */
-    bool                    fEnabled;
-    /** Path where to dump the debug output to.
-     *  Defaults to VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH. */
-    char                    szOutPath[RTPATH_MAX + 1];
-} HDASTATEDEBUG;
-
 /**
  * Shared ICH Intel HD audio controller state.
@@ -107 +78 @@
     /** Critical section protecting the HDA state. */
     PDMCRITSECT             CritSect;
-    /** R3 Pointer to the device instance. */
-    PPDMDEVINSR3            pDevInsR3;
-    /** The base interface for LUN\#0. */
-    PDMIBASE                IBase;
     /** The HDA's register set. */
     uint32_t                au32Regs[HDA_NUM_REGS];
     /** Internal stream states. */
     HDASTREAM               aStreams[HDA_MAX_STREAMS];
-    /** Mapping table between stream tags and stream states. */
-    HDATAG                  aTags[HDA_MAX_TAGS];
     /** CORB buffer base address. */
     uint64_t                u64CORBBase;
@@ -124 +89 @@
      *  Made out of DPLBASE + DPUBASE (3.3.32 + 3.3.33). */
     uint64_t                u64DPBase;
-    /** Pointer to CORB buffer. */
-    R3PTRTYPE(uint32_t *)   pu32CorbBuf;
-    /** Size in bytes of CORB buffer. */
+    /** Size in bytes of CORB buffer (#au32CorbBuf). */
     uint32_t                cbCorbBuf;
-    /** Padding for alignment. */
-    uint32_t                u32Padding1;
-    /** Pointer to RIRB buffer. */
-    R3PTRTYPE(uint64_t *)   pu64RirbBuf;
-    /** Size in bytes of RIRB buffer. */
+    /** Size in bytes of RIRB buffer (#au64RirbBuf). */
     uint32_t                cbRirbBuf;
-    /** DMA position buffer enable bit. */
-    bool                    fDMAPosition;
-    /** Reserved. */
-    bool                    afPadding1b[2];
-    /** Number of active (running) SDn streams. */
-    uint8_t                 cStreamsActive;
-    /** Pointer to HDA codec to use. */
-    R3PTRTYPE(PHDACODEC)    pCodec;
-    /** List of associated LUN drivers (HDADRIVER). */
-    RTLISTANCHORR3          lstDrv;
-    /** The device' software mixer. */
-    R3PTRTYPE(PAUDIOMIXER)  pMixer;
-    /** HDA sink for (front) output. */
-    HDAMIXERSINK            SinkFront;
-#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    /** HDA sink for center / LFE output. */
-    HDAMIXERSINK            SinkCenterLFE;
-    /** HDA sink for rear output. */
-    HDAMIXERSINK            SinkRear;
-#endif
-    /** HDA mixer sink for line input. */
-    HDAMIXERSINK            SinkLineIn;
-#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    /** Audio mixer sink for microphone input. */
-    HDAMIXERSINK            SinkMicIn;
-#endif
-    /** Last updated wall clock (WALCLK) counter. */
-    uint64_t                u64WalClk;
     /** Response Interrupt Count (RINTCNT). */
     uint16_t                u16RespIntCnt;
@@ -177 +108 @@
     /** Whether the position adjustment is enabled or not. */
     bool                    fPosAdjustEnabled;
+    /** DMA position buffer enable bit. */
+    bool                    fDMAPosition;
+    /** Current IRQ level. */
+    uint8_t                 u8IRQL;
 #ifdef VBOX_STRICT
     /** Wall clock (WALCLK) stale count.
@@ -182 +117 @@
      *  move the counter forward (stale). */
     uint8_t                 u8WalClkStaleCnt;
-    uint8_t                 Padding1[2];
 #else
-    uint8_t                 Padding1[3];
-#endif
-    /** Current IRQ level. */
-    uint8_t                 u8IRQL;
+    uint8_t                 bPadding1;
+#endif
     /** The device timer Hz rate. Defaults to HDA_TIMER_HZ_DEFAULT. */
     uint16_t                uTimerHz;
     /** Padding for alignment. */
-    uint8_t                 au8Padding3[3];
-    /** Debug stuff. */
-    HDASTATEDEBUG           Dbg;
+    uint16_t                au16Padding3[3];
+    /** Last updated wall clock (WALCLK) counter. */
+    uint64_t                u64WalClk;
+    /** The CORB buffer. */
+    uint32_t                au32CorbBuf[HDA_CORB_SIZE];
+    /** Pointer to RIRB buffer. */
+    uint64_t                au64RirbBuf[HDA_RIRB_SIZE];
 
     /** PCI Region \#0: 16KB of MMIO stuff. */
@@ -199 +135 @@
 
 #ifdef VBOX_WITH_STATISTICS
-    STAMPROFILE             StatTimer;
     STAMPROFILE             StatIn;
     STAMPROFILE             StatOut;
@@ -224 +159 @@
     /** @} */
 #endif
+
+#ifdef DEBUG
+    /** Debug stuff.
+     * @todo Make STAM values out some of this? */
+    struct
+    {
+# if 0 /* unused */
+        /** Timestamp (in ns) of the last timer callback (hdaTimer).
+         * Used to calculate the time actually elapsed between two timer callbacks. */
+        uint64_t                tsTimerLastCalledNs;
+# endif
+        /** IRQ debugging information. */
+        struct
+        {
+            /** Timestamp (in ns) of last processed (asserted / deasserted) IRQ. */
+            uint64_t            tsProcessedLastNs;
+            /** Timestamp (in ns) of last asserted IRQ. */
+            uint64_t            tsAssertedNs;
+# if 0 /* unused */
+            /** How many IRQs have been asserted already. */
+            uint64_t            cAsserted;
+            /** Accumulated elapsed time (in ns) of all IRQ being asserted. */
+            uint64_t            tsAssertedTotalNs;
+            /** Timestamp (in ns) of last deasserted IRQ. */
+            uint64_t            tsDeassertedNs;
+            /** How many IRQs have been deasserted already. */
+            uint64_t            cDeasserted;
+            /** Accumulated elapsed time (in ns) of all IRQ being deasserted. */
+            uint64_t            tsDeassertedTotalNs;
+# endif
+        } IRQ;
+    } Dbg;
+#endif
     /** This is for checking that the build was correctly configured in all contexts.
      *  This is set to HDASTATE_ALIGNMENT_CHECK_MAGIC. */
@@ -234 +202 @@
 #define HDASTATE_ALIGNMENT_CHECK_MAGIC  UINT64_C(0x1298afb75893e059)
 
+
+/**
+ * Ring-3 ICH Intel HD audio controller state.
+ */
+typedef struct HDASTATER3
+{
+    /** Internal stream states. */
+    HDASTREAMR3             aStreams[HDA_MAX_STREAMS];
+    /** Mapping table between stream tags and stream states. */
+    HDATAG                  aTags[HDA_MAX_TAGS];
+    /** Number of active (running) SDn streams. */
+    uint8_t                 cStreamsActive;
+    uint8_t                 abPadding0[7];
+    /** R3 Pointer to the device instance. */
+    PPDMDEVINSR3            pDevIns;
+    /** The base interface for LUN\#0. */
+    PDMIBASE                IBase;
+    /** Pointer to HDA codec to use. */
+    R3PTRTYPE(PHDACODEC)    pCodec;
+    /** List of associated LUN drivers (HDADRIVER). */
+    RTLISTANCHORR3          lstDrv;
+    /** The device' software mixer. */
+    R3PTRTYPE(PAUDIOMIXER)  pMixer;
+    /** HDA sink for (front) output. */
+    HDAMIXERSINK            SinkFront;
+#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
+    /** HDA sink for center / LFE output. */
+    HDAMIXERSINK            SinkCenterLFE;
+    /** HDA sink for rear output. */
+    HDAMIXERSINK            SinkRear;
+#endif
+    /** HDA mixer sink for line input. */
+    HDAMIXERSINK            SinkLineIn;
+#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
+    /** Audio mixer sink for microphone input. */
+    HDAMIXERSINK            SinkMicIn;
+#endif
+    /** Debug stuff. */
+    struct
+    {
+        /** Whether debugging is enabled or not. */
+        bool                    fEnabled;
+        /** Path where to dump the debug output to.
+         *  Defaults to VBOX_AUDIO_DEBUG_DUMP_PCM_DATA_PATH. */
+        char                    szOutPath[RTPATH_MAX];
+    } Dbg;
+} HDASTATER3;
+/** Pointer to a ring-3 HDA device state.  */
+typedef HDASTATER3 *PHDASTATER3;
+
+
 #endif /* !VBOX_INCLUDED_SRC_Audio_DevHDA_h */
 

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

@@ -41 +41 @@
  * Processes (de/asserts) the interrupt according to the HDA's current state.
  *
- * @returns IPRT status code.
  * @param   pDevIns             The device instance.
- * @param   pThis               HDA state.
+ * @param   pThis               The shared HDA device state.
  * @param   pszSource           Caller information.
  */
 #if defined(LOG_ENABLED) || defined(DOXYGEN_RUNNING)
-int hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis, const char *pszSource)
+void hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis, const char *pszSource)
 #else
-int hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis)
+void hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis)
 #endif
 {
@@ -80 +79 @@
         pThis->u8IRQL = 0;
     }
-
-    return VINF_SUCCESS;
 }
 
@@ -89 +86 @@
  * @return  IPRT status code.
  * @return  Currently set wall clock value.
- * @param   pThis               HDA state.
+ * @param   pThis               The shared HDA device state.
  *
  * @remark  Operation is atomic.
@@ -99 +96 @@
 
 #ifdef IN_RING3
+
+/**
+ * Helper for hdaR3WalClkSet.
+ */
+DECLINLINE(PHDASTREAMPERIOD) hdaR3SinkToStreamPeriod(PHDAMIXERSINK pSink)
+{
+    PHDASTREAM pStream = hdaR3GetSharedStreamFromSink(pSink);
+    if (pStream)
+        return &pStream->State.Period;
+    return NULL;
+}
 
 /**
@@ -107 +115 @@
  *
  * @return  true if the WALCLK register has been updated, false if not.
- * @param   pThis               HDA state.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   u64WalClk           Wall clock value to set WALCLK register to.
  * @param   fForce              Whether to force setting the wall clock value or not.
  */
-bool hdaR3WalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce)
-{
-    const bool     fFrontPassed       = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkFront)->State.Period,
-                                                                           u64WalClk);
-    const uint64_t u64FrontAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkFront)->State.Period);
+bool hdaR3WalClkSet(PHDASTATE pThis, PHDASTATER3 pThisCC, uint64_t u64WalClk, bool fForce)
+{
+    const bool     fFrontPassed       = hdaR3StreamPeriodHasPassedAbsWalClk( hdaR3SinkToStreamPeriod(&pThisCC->SinkFront), u64WalClk);
+    const uint64_t u64FrontAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(hdaR3SinkToStreamPeriod(&pThisCC->SinkFront));
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
 #  error "Implement me!"
 # endif
 
-    const bool     fLineInPassed      = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period, u64WalClk);
-    const uint64_t u64LineInAbsWalClk = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkLineIn)->State.Period);
+    const bool     fLineInPassed      = hdaR3StreamPeriodHasPassedAbsWalClk (hdaR3SinkToStreamPeriod(&pThisCC->SinkLineIn), u64WalClk);
+    const uint64_t u64LineInAbsWalClk = hdaR3StreamPeriodGetAbsElapsedWalClk(hdaR3SinkToStreamPeriod(&pThisCC->SinkLineIn));
 # ifdef VBOX_WITH_HDA_MIC_IN
-    const bool     fMicInPassed       = hdaR3StreamPeriodHasPassedAbsWalClk (&hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period,  u64WalClk);
-    const uint64_t u64MicInAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(&hdaR3GetStreamFromSink(pThis, &pThis->SinkMicIn)->State.Period);
+    const bool     fMicInPassed       = hdaR3StreamPeriodHasPassedAbsWalClk (hdaR3SinkToStreamPeriod(&pThisCC->SinkMicIn),  u64WalClk);
+    const uint64_t u64MicInAbsWalClk  = hdaR3StreamPeriodGetAbsElapsedWalClk(hdaR3SinkToStreamPeriod(&pThisCC->SinkMicIn));
 # endif
 
@@ -190 +198 @@
  *
  * @return  PHDAMIXERSINK
- * @param   pThis               HDA state.
+ * @param   pThisCC             The ring-3 HDA device state.
  * @param   uSD                 SD# to return mixer sink for.
  *                              NULL if not found / handled.
  */
-PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATE pThis, uint8_t uSD)
+PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATER3 pThisCC, uint8_t uSD)
 {
     if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
@@ -201 +209 @@
 
         if (uSD == uFirstSDI) /* First SDI. */
-            return &pThis->SinkLineIn;
+            return &pThisCC->SinkLineIn;
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
         if (uSD == uFirstSDI + 1)
-            return &pThis->SinkMicIn;
+            return &pThisCC->SinkMicIn;
 # else
         /* If we don't have a dedicated Mic-In sink, use the always present Line-In sink. */
-        return &pThis->SinkLineIn;
+        return &pThisCC->SinkLineIn;
 # endif
     }
@@ -215 +223 @@
 
         if (uSD == uFirstSDO)
-            return &pThis->SinkFront;
+            return &pThisCC->SinkFront;
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
         if (uSD == uFirstSDO + 1)
-            return &pThis->SinkCenterLFE;
+            return &pThisCC->SinkCenterLFE;
         if (uSD == uFirstSDO + 2)
-            return &pThis->SinkRear;
+            return &pThisCC->SinkRear;
 # endif
     }
@@ -270 +278 @@
  * @return  Pointer to HDA stream, or NULL if none found.
  */
-PHDASTREAM hdaR3GetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
-{
-    AssertPtrReturn(pThis, NULL);
+PHDASTREAMR3 hdaR3GetR3StreamFromSink(PHDAMIXERSINK pSink)
+{
     AssertPtrReturn(pSink, NULL);
 
     /** @todo Do something with the channel mapping here? */
-    return pSink->pStream;
-}
-
-/**
+    return pSink->pStreamR3;
+}
+
+
+/**
+ * Returns the HDA stream of specified HDA sink.
+ *
+ * @return  Pointer to HDA stream, or NULL if none found.
+ */
+PHDASTREAM hdaR3GetSharedStreamFromSink(PHDAMIXERSINK pSink)
+{
+    AssertPtrReturn(pSink, NULL);
+
+    /** @todo Do something with the channel mapping here? */
+    return pSink->pStreamShared;
+}
+
+/*
  * Reads DMA data from a given HDA output stream.
  *
  * @return  IPRT status code.
- * @param   pThis               HDA state.
- * @param   pStream             HDA output stream to read DMA data from.
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state (for stats).
+ * @param   pStreamShared       HDA output stream to read DMA data from - shared bits.
+ * @param   pStreamR3           HDA output stream to read DMA data from - shared ring-3.
  * @param   pvBuf               Where to store the read data.
  * @param   cbBuf               How much to read in bytes.
  * @param   pcbRead             Returns read bytes from DMA. Optional.
  */
-int hdaR3DMARead(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
-{
-    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /* pcbRead is optional. */
-
-    PHDABDLE pBDLE       = &pStream->State.BDLE;
+int hdaR3DMARead(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3,
+                 void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
+{
+    RT_NOREF(pThis);
+    PHDABDLE pBDLE = &pStreamShared->State.BDLE;
 
     int rc = VINF_SUCCESS;
@@ -305 +326 @@
     uint64_t   csSilence = 0;
 
-    pStream->Dbg.cSilenceThreshold = 100;
-    pStream->Dbg.cbSilenceReadMin  = _1M;
-# endif
-
-    RTGCPHYS addrChunk = pBDLE->Desc.u64BufAddr + pBDLE->State.u32BufOff;
+    pStreamCC->Dbg.cSilenceThreshold = 100;
+    pStreamCC->Dbg.cbSilenceReadMin  = _1M;
+# endif
+
+    RTGCPHYS GCPhysChunk = pBDLE->Desc.u64BufAddr + pBDLE->State.u32BufOff;
 
     while (cbLeft)
     {
-        uint32_t cbChunk = RT_MIN(cbLeft, pStream->u16FIFOS);
-
-        rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), addrChunk, (uint8_t *)pvBuf + cbReadTotal, cbChunk);
-        if (RT_FAILURE(rc))
-            break;
+        uint32_t cbChunk = RT_MIN(cbLeft, pStreamShared->u16FIFOS);
+
+        rc = PDMDevHlpPhysRead(pDevIns, GCPhysChunk, (uint8_t *)pvBuf + cbReadTotal, cbChunk);
+        AssertRCBreak(rc);
 
 # ifdef HDA_DEBUG_SILENCE
@@ -330 +350 @@
         }
 # endif
-        if (pStream->Dbg.Runtime.fEnabled)
-            DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbReadTotal, cbChunk, 0 /* fFlags */);
+        if (RT_LIKELY(!pStreamR3->Dbg.Runtime.fEnabled))
+        { /* likely */ }
+        else
+            DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbReadTotal, cbChunk, 0 /* fFlags */);
 
         STAM_COUNTER_ADD(&pThis->StatBytesRead, cbChunk);
-        addrChunk         = (addrChunk + cbChunk) % pBDLE->Desc.u32BufSize;
-
+
+        /* advance */
         Assert(cbLeft    >= cbChunk);
+        GCPhysChunk       = (GCPhysChunk + cbChunk) % pBDLE->Desc.u32BufSize;
+        cbReadTotal      += cbChunk;
         cbLeft           -= cbChunk;
-
-        cbReadTotal      += cbChunk;
     }
 
 # ifdef HDA_DEBUG_SILENCE
     if (csSilence)
-        pStream->Dbg.csSilence += csSilence;
+        pStreamR3->Dbg.csSilence += csSilence;
 
     if (   csSilence == 0
-        && pStream->Dbg.csSilence   >  pStream->Dbg.cSilenceThreshold
-        && pStream->Dbg.cbReadTotal >= pStream->Dbg.cbSilenceReadMin)
-    {
-        LogFunc(("Silent block detected: %RU64 audio samples\n", pStream->Dbg.csSilence));
-        pStream->Dbg.csSilence = 0;
+        && pStreamR3->Dbg.csSilence   >  pStreamR3->Dbg.cSilenceThreshold
+        && pStreamR3->Dbg.cbReadTotal >= pStreamR3->Dbg.cbSilenceReadMin)
+    {
+        LogFunc(("Silent block detected: %RU64 audio samples\n", pStreamR3->Dbg.csSilence));
+        pStreamR3->Dbg.csSilence = 0;
     }
 # endif
@@ -368 +390 @@
  *
  * @return  IPRT status code.
- * @param   pThis               HDA state.
- * @param   pStream             HDA input stream to write audio data to.
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state (for stats).
+ * @param   pStreamShared       HDA input stream to write audio data to - shared.
+ * @param   pStreamR3           HDA input stream to write audio data to - ring-3.
  * @param   pvBuf               Data to write.
  * @param   cbBuf               How much (in bytes) to write.
  * @param   pcbWritten          Returns written bytes on success. Optional.
  */
-int hdaR3DMAWrite(PHDASTATE pThis, PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
-{
-    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /* pcbWritten is optional. */
-
-    PHDABDLE pBDLE  = &pStream->State.BDLE;
-
-    int rc = VINF_SUCCESS;
-
-    uint32_t cbWrittenTotal = 0;
-    uint32_t cbLeft = RT_MIN(cbBuf, pBDLE->Desc.u32BufSize - pBDLE->State.u32BufOff);
-
-    RTGCPHYS addrChunk = pBDLE->Desc.u64BufAddr + pBDLE->State.u32BufOff;
-
+int hdaR3DMAWrite(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3,
+                  const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+{
+    RT_NOREF(pThis);
+    PHDABDLE    pBDLE          = &pStreamShared->State.BDLE;
+    int         rc             = VINF_SUCCESS;
+    uint32_t    cbWrittenTotal = 0;
+    uint32_t    cbLeft         = RT_MIN(cbBuf, pBDLE->Desc.u32BufSize - pBDLE->State.u32BufOff);
+    RTGCPHYS    GCPhysChunk    = pBDLE->Desc.u64BufAddr + pBDLE->State.u32BufOff;
     while (cbLeft)
     {
-        uint32_t cbChunk = RT_MIN(cbLeft, pStream->u16FIFOS);
+        uint32_t cbChunk = RT_MIN(cbLeft, pStreamShared->u16FIFOS);
 
         /* Sanity checks. */
         Assert(cbChunk <= pBDLE->Desc.u32BufSize - pBDLE->State.u32BufOff);
 
-        if (pStream->Dbg.Runtime.fEnabled)
-            DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk, 0 /* fFlags */);
-
-        rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
-                                   addrChunk, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk);
-        if (RT_FAILURE(rc))
-            break;
+        if (RT_LIKELY(!pStreamR3->Dbg.Runtime.fEnabled))
+        { /* likely */ }
+        else
+            DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk, 0 /* fFlags */);
+
+        rc = PDMDevHlpPCIPhysWrite(pDevIns, GCPhysChunk, (uint8_t *)pvBuf + cbWrittenTotal, cbChunk);
+        AssertRCReturn(rc, rc);
 
         STAM_COUNTER_ADD(&pThis->StatBytesWritten, cbChunk);
-        addrChunk       = (addrChunk + cbChunk) % pBDLE->Desc.u32BufSize;
-
+
+        /* advance */
         Assert(cbLeft  >= cbChunk);
-        cbLeft -= (uint32_t)cbChunk;
-
         cbWrittenTotal += (uint32_t)cbChunk;
+        GCPhysChunk     = (GCPhysChunk + cbChunk) % pBDLE->Desc.u32BufSize;
+        cbLeft         -= (uint32_t)cbChunk;
     }
 
@@ -430 +448 @@
  *
  * @returns Determined INTSTS register value.
- * @param   pThis               HDA state.
+ * @param   pThis               The shared HDA device state.
  *
  * @remark  This function does *not* set INTSTS!
@@ -554 +572 @@
 
 # ifdef LOG_ENABLED
-void hdaR3BDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE)
+void hdaR3BDLEDumpAll(PPDMDEVINS pDevIns, PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE)
 {
     LogFlowFunc(("BDLEs @ 0x%x (%RU16):\n", u64BDLBase, cBDLE));
@@ -564 +582 @@
     {
         HDABDLEDESC bd;
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BDLBase + i * sizeof(HDABDLEDESC), &bd, sizeof(bd));
+        PDMDevHlpPhysRead(pDevIns, u64BDLBase + i * sizeof(HDABDLEDESC), &bd, sizeof(bd));
 
         LogFunc(("\t#%03d BDLE(adr:0x%llx, size:%RU32, ioc:%RTbool)\n",
@@ -582 +600 @@
     {
         uint32_t uDMACnt;
-        PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
+        PDMDevHlpPhysRead(pDevIns, (pThis->u64DPBase & DPBASE_ADDR_MASK) + (i * 2 * sizeof(uint32_t)),
                           &uDMACnt, sizeof(uDMACnt));
 
@@ -593 +611 @@
  * Fetches a Bundle Descriptor List Entry (BDLE) from the DMA engine.
  *
- * @param   pThis                   Pointer to HDA state.
- * @param   pBDLE                   Where to store the fetched result.
- * @param   u64BaseDMA              Address base of DMA engine to use.
- * @param   u16Entry                BDLE entry to fetch.
- */
-int hdaR3BDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry)
-{
-    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+ * @param   pDevIns             The device instance.
+ * @param   pBDLE               Where to store the fetched result.
+ * @param   u64BaseDMA          Address base of DMA engine to use.
+ * @param   u16Entry            BDLE entry to fetch.
+ */
+int hdaR3BDLEFetch(PPDMDEVINS pDevIns, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry)
+{
     AssertPtrReturn(pBDLE,   VERR_INVALID_POINTER);
     AssertReturn(u64BaseDMA, VERR_INVALID_PARAMETER);
@@ -611 +628 @@
     /** @todo Compare u16Entry with LVI. */
 
-    int rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns), u64BaseDMA + (u16Entry * sizeof(HDABDLEDESC)),
+    int rc = PDMDevHlpPhysRead(pDevIns, u64BaseDMA + (u16Entry * sizeof(HDABDLEDESC)),
                                &pBDLE->Desc, sizeof(pBDLE->Desc));
 
@@ -664 +681 @@
  *
  * @returns Whether the new expiration time was set or not.
- * @param   pDevIns     The device instance.
- * @param   pStream     HDA stream to set timer for.
- * @param   tsExpire    New (virtual) expiration time to set.
- * @param   fForce      Whether to force setting the expiration time or not.
- * @param   tsNow       The current clock timestamp if available, 0 if not.
+ * @param   pDevIns         The device instance.
+ * @param   pStreamShared   HDA stream to set timer for (shared).
+ * @param   tsExpire        New (virtual) expiration time to set.
+ * @param   fForce          Whether to force setting the expiration time or not.
+ * @param   tsNow           The current clock timestamp if available, 0 if not.
  *
  * @remark  This function takes all active HDA streams and their
@@ -679 +696 @@
  *          Forcing a new expiration time will override the above mechanism.
  */
-bool hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint64_t tsExpire, bool fForce, uint64_t tsNow)
-{
-    AssertPtr(pStream);
+bool hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTREAM pStreamShared, uint64_t tsExpire, bool fForce, uint64_t tsNow)
+{
+    AssertPtr(pStreamShared);
 
     if (!tsNow)
-        tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
+        tsNow = PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer);
 
     if (!fForce)
@@ -691 +708 @@
          * PDMDevHlpTimerGet(), so, some callers does one, this does, and then we do
          * right afterwards == very inefficient! */
-        if (hdaR3StreamTransferIsScheduled(pStream, tsNow))
+        if (hdaR3StreamTransferIsScheduled(pStreamShared, tsNow))
         {
-            uint64_t const tsNext = hdaR3StreamTransferGetNext(pStream);
+            uint64_t const tsNext = hdaR3StreamTransferGetNext(pStreamShared);
             if (tsExpire > tsNext)
                 tsExpire = tsNext;
@@ -706 +723 @@
         tsExpire = tsNow;
 
-    int rc = PDMDevHlpTimerSet(pDevIns, pStream->hTimer, tsExpire);
+    int rc = PDMDevHlpTimerSet(pDevIns, pStreamShared->hTimer, tsExpire);
     AssertRCReturn(rc, false);
 

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

@@ -25 +25 @@
 #include <VBox/log.h> /* LOG_ENABLED */
 
-    /** Read callback. */
+/** Pointer to an HDA stream (SDI / SDO).  */
+typedef struct HDASTREAMR3 *PHDASTREAMR3;
+
+
+
+/** Read callback. */
 typedef VBOXSTRICTRC FNHDAREGREAD(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
-    /** Write callback. */
+/** Write callback. */
 typedef VBOXSTRICTRC FNHDAREGWRITE(PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 
@@ -598 +603 @@
  */
 #ifdef IN_RING3
-PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATE pThis, uint8_t uSD);
+PHDAMIXERSINK hdaR3GetDefaultSink(PHDASTATER3 pThisCC, uint8_t uSD);
 #endif
 PDMAUDIODIR   hdaGetDirFromSD(uint8_t uSD);
-PHDASTREAM    hdaGetStreamFromSD(PHDASTATE pThis, uint8_t uSD);
+//PHDASTREAM    hdaGetStreamFromSD(PHDASTATER3 pThisCC, uint8_t uSD);
 #ifdef IN_RING3
-PHDASTREAM    hdaR3GetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink);
+PHDASTREAMR3  hdaR3GetR3StreamFromSink(PHDAMIXERSINK pSink);
+PHDASTREAM    hdaR3GetSharedStreamFromSink(PHDAMIXERSINK pSink);
 #endif
 /** @} */
@@ -610 +616 @@
  * @{
  */
-#ifdef LOG_ENABLED
-int           hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis, const char *pszSource);
+#if defined(LOG_ENABLED) || defined(DOXYGEN_RUNNING)
+void          hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis, const char *pszSource);
 # define HDA_PROCESS_INTERRUPT(a_pDevIns, a_pThis)  hdaProcessInterrupt((a_pDevIns), (a_pThis), __FUNCTION__)
 #else
-int           hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis);
+void          hdaProcessInterrupt(PPDMDEVINS pDevIns, PHDASTATE pThis);
 # define HDA_PROCESS_INTERRUPT(a_pDevIns, a_pThis)  hdaProcessInterrupt((a_pDevIns), (a_pThis))
 #endif
@@ -624 +630 @@
 uint64_t      hdaWalClkGetCurrent(PHDASTATE pThis);
 #ifdef IN_RING3
-bool          hdaR3WalClkSet(PHDASTATE pThis, uint64_t u64WalClk, bool fForce);
+bool          hdaR3WalClkSet(PHDASTATE pThis, PHDASTATER3 pThisCC, uint64_t u64WalClk, bool fForce);
 #endif
 /** @} */
@@ -632 +638 @@
  */
 #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);
+int           hdaR3DMARead(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3,
+                           void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead);
+int           hdaR3DMAWrite(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3,
+                            const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten);
 #endif
 /** @} */
@@ -651 +659 @@
 #ifdef IN_RING3
 # ifdef LOG_ENABLED
-void          hdaR3BDLEDumpAll(PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE);
+void          hdaR3BDLEDumpAll(PPDMDEVINS pDevIns, PHDASTATE pThis, uint64_t u64BDLBase, uint16_t cBDLE);
 # endif
-int           hdaR3BDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
+int           hdaR3BDLEFetch(PPDMDEVINS pDevIns, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
 bool          hdaR3BDLEIsComplete(PHDABDLE pBDLE);
 bool          hdaR3BDLENeedsInterrupt(PHDABDLE pBDLE);
@@ -663 +671 @@
  */
 #ifdef IN_RING3
-bool          hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint64_t u64Expire, bool fForce, uint64_t tsNow);
+bool          hdaR3TimerSet(PPDMDEVINS pDevIns, PHDASTREAM pStreamShared, uint64_t u64Expire, bool fForce, uint64_t tsNow);
 #endif
 /** @} */

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

@@ -1631 +1631 @@
              DrvAudioHlpAudMixerCtlToStr(enmMixerCtl), lVol, rVol, RT_BOOL(iMute) ? "Muted" : "Unmuted"));
 
-    return pThis->pfnCbMixerSetVolume(pThis->pHDAState, enmMixerCtl, &Vol);
+    return pThis->pfnCbMixerSetVolume(pThis->pDevIns, enmMixerCtl, &Vol);
 }
 
@@ -2412 +2412 @@
 
             /* Propagate to the controller. */
-            pThis->pfnCbMixerControl(pThis->pHDAState, PDMAUDIOMIXERCTL_FRONT,      uSD, uChannel);
+            pThis->pfnCbMixerControl(pThis->pDevIns, PDMAUDIOMIXERCTL_FRONT,      uSD, uChannel);
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-            pThis->pfnCbMixerControl(pThis->pHDAState, PDMAUDIOMIXERCTL_CENTER_LFE, uSD, uChannel);
-            pThis->pfnCbMixerControl(pThis->pHDAState, PDMAUDIOMIXERCTL_REAR,       uSD, uChannel);
+            pThis->pfnCbMixerControl(pThis->pDevIns, PDMAUDIOMIXERCTL_CENTER_LFE, uSD, uChannel);
+            pThis->pfnCbMixerControl(pThis->pDevIns, PDMAUDIOMIXERCTL_REAR,       uSD, uChannel);
 #endif
         }
         else if (enmDir == PDMAUDIODIR_IN)
         {
-            pThis->pfnCbMixerControl(pThis->pHDAState, PDMAUDIOMIXERCTL_LINE_IN,    uSD, uChannel);
+            pThis->pfnCbMixerControl(pThis->pDevIns, PDMAUDIOMIXERCTL_LINE_IN,    uSD, uChannel);
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-            pThis->pfnCbMixerControl(pThis->pHDAState, PDMAUDIOMIXERCTL_MIC_IN,     uSD, uChannel);
+            pThis->pfnCbMixerControl(pThis->pDevIns, PDMAUDIOMIXERCTL_MIC_IN,     uSD, uChannel);
 #endif
         }
@@ -3065 +3065 @@
         case PDMAUDIOMIXERCTL_REAR:
 #endif
-        {
             break;
-        }
+
         case PDMAUDIOMIXERCTL_LINE_IN:
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
         case PDMAUDIOMIXERCTL_MIC_IN:
 #endif
-        {
             break;
-        }
+
         default:
             AssertMsgFailed(("Mixer control %d not implemented\n", enmMixerCtl));
@@ -3082 +3080 @@
 
     if (RT_SUCCESS(rc))
-        rc = pThis->pfnCbMixerAddStream(pThis->pHDAState, enmMixerCtl, pCfg);
+        rc = pThis->pfnCbMixerAddStream(pThis->pDevIns, enmMixerCtl, pCfg);
 
     LogFlowFuncLeaveRC(rc);
@@ -3092 +3090 @@
     AssertPtrReturn(pThis, VERR_INVALID_POINTER);
 
-    int rc = pThis->pfnCbMixerRemoveStream(pThis->pHDAState, enmMixerCtl);
+    int rc = pThis->pfnCbMixerRemoveStream(pThis->pDevIns, enmMixerCtl);
 
     LogFlowFuncLeaveRC(rc);

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

@@ -26 +26 @@
 #include "AudioMixer.h"
 
-/** The ICH HDA (Intel) controller. */
+/** Pointer to a shared HDA device state.  */
 typedef struct HDASTATE *PHDASTATE;
+/** Pointer to a ring-3 HDA device state.  */
+typedef struct HDASTATER3 *PHDASTATER3;
 /** The ICH HDA (Intel) codec state. */
 typedef struct HDACODEC *PHDACODEC;
 /** The HDA host driver backend. */
 typedef struct HDADRIVER *PHDADRIVER;
-typedef struct PDMIAUDIOCONNECTOR *PPDMIAUDIOCONNECTOR;
-typedef struct PDMAUDIOGSTSTRMOUT *PPDMAUDIOGSTSTRMOUT;
-typedef struct PDMAUDIOGSTSTRMIN  *PPDMAUDIOGSTSTRMIN;
 
 /**
@@ -41 +40 @@
 typedef DECLCALLBACK(int) FNHDACODECVERBPROCESSOR(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp);
 typedef FNHDACODECVERBPROCESSOR *PFNHDACODECVERBPROCESSOR;
-typedef FNHDACODECVERBPROCESSOR **PPFNHDACODECVERBPROCESSOR;
 
 /* PRM 5.3.1 */
@@ -71 +69 @@
     uint8_t                 u8BSKU;
     uint8_t                 u8AssemblyId;
+
     /** List of assigned HDA drivers to this codec.
      * A driver only can be assigned to one codec at a time. */
@@ -79 +78 @@
 
     PCODECNODE              paNodes;
-    /** Pointer to HDA state (controller) this
-     *  codec is assigned to. */
-    PHDASTATE               pHDAState;
+
     bool                    fInReset;
+    uint8_t                 abPadding1[3];
 
     const uint8_t           cTotalNodes;
+    const uint8_t           u8AdcVolsLineIn;
+    const uint8_t           u8DacLineOut;
+    uint8_t                 bPadding2;
     const uint8_t          *au8Ports;
     const uint8_t          *au8Dacs;
@@ -98 +99 @@
     const uint8_t          *au8VolKnobs;
     const uint8_t          *au8Reserveds;
-    const uint8_t           u8AdcVolsLineIn;
-    const uint8_t           u8DacLineOut;
 
     /** @name Public codec functions.
@@ -106 +105 @@
     DECLR3CALLBACKMEMBER(void, pfnReset, (PHDACODEC pThis));
     DECLR3CALLBACKMEMBER(int,  pfnNodeReset, (PHDACODEC pThis, uint8_t, PCODECNODE));
+    DECLR3CALLBACKMEMBER(void, pfnDbgListNodes, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
+    DECLR3CALLBACKMEMBER(void, pfnDbgSelector, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
     /** @} */
+
+    /** The parent device instance. */
+    PPDMDEVINS              pDevIns;
 
     /** @name Callbacks to the HDA controller, mostly used for multiplexing to the
      *        various host backends.
      * @{ */
-    DECLR3CALLBACKMEMBER(int,  pfnCbMixerAddStream, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg));
-    DECLR3CALLBACKMEMBER(int,  pfnCbMixerRemoveStream, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl));
-    DECLR3CALLBACKMEMBER(int,  pfnCbMixerControl, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel));
-    DECLR3CALLBACKMEMBER(int,  pfnCbMixerSetVolume, (PHDASTATE pThis, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol));
-    /** @} */
-
-    /** @name These callbacks are set by codec implementation to answer debugger requests.
-     * @{ */
-    DECLR3CALLBACKMEMBER(void, pfnDbgListNodes, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
-    DECLR3CALLBACKMEMBER(void, pfnDbgSelector, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
+    /**
+     *
+     * Adds a new audio stream to a specific mixer control.
+     *
+     * Depending on the mixer control the stream then gets assigned to one of the
+     * internal mixer sinks, which in turn then handle the mixing of all connected
+     * streams to that sink.
+     *
+     * @return  VBox status code.
+     * @param   pThisCC             The ring-3 HDA device state.
+     * @param   enmMixerCtl         Mixer control to assign new stream to.
+     * @param   pCfg                Stream configuration for the new stream.
+     */
+    DECLR3CALLBACKMEMBER(int,  pfnCbMixerAddStream, (PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOSTREAMCFG pCfg));
+    /**
+     * Removes a specified mixer control from the HDA's mixer.
+     *
+     * @return  VBox status code.
+     * @param   pThisCC             The ring-3 HDA device state.
+     * @param   enmMixerCtl         Mixer control to remove.
+     */
+    DECLR3CALLBACKMEMBER(int,  pfnCbMixerRemoveStream, (PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl));
+    /**
+     * Controls an input / output converter widget, that is, which converter is
+     * connected to which stream (and channel).
+     *
+     * @return  VBox status code.
+     * @param   pThisCC             The ring-3 HDA device state.
+     * @param   enmMixerCtl         Mixer control to set SD stream number and channel for.
+     * @param   uSD                 SD stream number (number + 1) to set. Set to 0 for unassign.
+     * @param   uChannel            Channel to set. Only valid if a valid SD stream number is specified.
+     */
+    DECLR3CALLBACKMEMBER(int,  pfnCbMixerControl, (PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, uint8_t uSD, uint8_t uChannel));
+    /**
+     * Sets the volume of a specified mixer control.
+     *
+     * @return  IPRT status code.
+     * @param   pThisCC             The ring-3 HDA device state.
+     * @param   enmMixerCtl         Mixer control to set volume for.
+     * @param   pVol                Pointer to volume data to set.
+     */
+    DECLR3CALLBACKMEMBER(int,  pfnCbMixerSetVolume, (PPDMDEVINS pDevIns, PDMAUDIOMIXERCTL enmMixerCtl, PPDMAUDIOVOLUME pVol));
     /** @} */
 

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

@@ -36 +36 @@
 
 
-#ifdef IN_RING3
+#ifdef IN_RING3 /* whole file */
+
+/*********************************************************************************************************************************
+*   Internal Functions                                                                                                           *
+*********************************************************************************************************************************/
+static void hdaR3StreamSetPosition(PHDASTREAM pStreamShared, PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t u32LPIB);
+
+static int  hdaR3StreamAsyncIODestroy(PHDASTREAMR3 pStreamR3);
+static int  hdaR3StreamAsyncIONotify(PHDASTREAMR3 pStreamR3);
+
+
 
 /**
@@ -42 +52 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to create.
- * @param   pThis               HDA state to assign the HDA stream to.
- * @param   u8SD                Stream descriptor number to assign.
- */
-int hdaR3StreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD)
+ * @param   pStreamShared       The HDA stream to construct - shared bits.
+ * @param   pStreamR3           The HDA stream to construct - ring-3 bits.
+ * @param   pThis               The shared HDA device instance.
+ * @param   pThisCC             The ring-3 HDA device instance.
+ * @param   uSD                 Stream descriptor number to assign.
+ */
+int hdaR3StreamConstruct(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, PHDASTATE pThis, PHDASTATER3 pThisCC, uint8_t uSD)
 {
     int rc;
-    RT_NOREF(pThis);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    pStream->u8SD           = u8SD;
-    pStream->pMixSink       = NULL;
-    pStream->pHDAState      = pThis;
-    Assert(pStream->hTimer != NIL_TMTIMERHANDLE); /* hdaR3Construct initalized this one already. */
-
-    pStream->State.fInReset = false;
-    pStream->State.fRunning = false;
+
+    pStreamR3->u8SD             = uSD;
+    pStreamShared->u8SD         = uSD;
+    pStreamR3->pMixSink         = NULL;
+    pStreamR3->pHDAStateShared  = pThis;
+    pStreamR3->pHDAStateR3      = pThisCC;
+    Assert(pStreamShared->hTimer != NIL_TMTIMERHANDLE); /* hdaR3Construct initalized this one already. */
+
+    pStreamShared->State.fInReset = false;
+    pStreamShared->State.fRunning = false;
 #ifdef HDA_USE_DMA_ACCESS_HANDLER
-    RTListInit(&pStream->State.lstDMAHandlers);
+    RTListInit(&pStreamR3->State.lstDMAHandlers);
 #endif
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    rc = RTCritSectInit(&pStream->CritSect);
+    rc = RTCritSectInit(&pStreamR3->CritSect);
     AssertRCReturn(rc, rc);
 # endif
 
-    rc = hdaR3StreamPeriodCreate(&pStream->State.Period);
+    rc = hdaR3StreamPeriodCreate(&pStreamShared->State.Period);
     AssertRCReturn(rc, rc);
 
-    pStream->State.tsLastUpdateNs = 0;
+    pStreamShared->State.tsLastUpdateNs = 0;
 
 #ifdef DEBUG
-    rc = RTCritSectInit(&pStream->Dbg.CritSect);
+    rc = RTCritSectInit(&pStreamR3->Dbg.CritSect);
     AssertRCReturn(rc, rc);
 #endif
 
-    pStream->Dbg.Runtime.fEnabled = pThis->Dbg.fEnabled;
-
-    if (pStream->Dbg.Runtime.fEnabled)
+    pStreamR3->Dbg.Runtime.fEnabled = pThisCC->Dbg.fEnabled;
+
+    if (pStreamR3->Dbg.Runtime.fEnabled)
     {
         char szFile[64];
-
-        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
-            RTStrPrintf(szFile, sizeof(szFile), "hdaStreamWriteSD%RU8", pStream->u8SD);
+        char szPath[RTPATH_MAX];
+
+        /* pFileStream */
+        if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
+            RTStrPrintf(szFile, sizeof(szFile), "hdaStreamWriteSD%RU8", uSD);
         else
-            RTStrPrintf(szFile, sizeof(szFile), "hdaStreamReadSD%RU8", pStream->u8SD);
-
-        char szPath[RTPATH_MAX + 1];
-        int rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThis->Dbg.szOutPath, szFile,
+            RTStrPrintf(szFile, sizeof(szFile), "hdaStreamReadSD%RU8", uSD);
+
+        int rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.szOutPath, szFile,
                                          0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStream->Dbg.Runtime.pFileStream);
+
+        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileStream);
         AssertRC(rc2);
 
-        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
-            RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawWriteSD%RU8", pStream->u8SD);
+        /* pFileDMARaw */
+        if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
+            RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawWriteSD%RU8", uSD);
         else
-            RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawReadSD%RU8", pStream->u8SD);
-
-        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThis->Dbg.szOutPath, szFile,
+            RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawReadSD%RU8", uSD);
+
+        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.szOutPath, szFile,
                                      0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStream->Dbg.Runtime.pFileDMARaw);
+        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMARaw);
         AssertRC(rc2);
 
-        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
-            RTStrPrintf(szFile, sizeof(szFile), "hdaDMAWriteMappedSD%RU8", pStream->u8SD);
+        /* pFileDMAMapped */
+        if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN)
+            RTStrPrintf(szFile, sizeof(szFile), "hdaDMAWriteMappedSD%RU8", uSD);
         else
-            RTStrPrintf(szFile, sizeof(szFile), "hdaDMAReadMappedSD%RU8", pStream->u8SD);
-
-        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThis->Dbg.szOutPath, szFile,
+            RTStrPrintf(szFile, sizeof(szFile), "hdaDMAReadMappedSD%RU8", uSD);
+
+        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.szOutPath, szFile,
                                      0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStream->Dbg.Runtime.pFileDMAMapped);
+        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMAMapped);
         AssertRC(rc2);
 
         /* Delete stale debugging files from a former run. */
-        DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileStream);
-        DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMARaw);
-        DrvAudioHlpFileDelete(pStream->Dbg.Runtime.pFileDMAMapped);
+        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileStream);
+        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMARaw);
+        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMAMapped);
     }
 
@@ -132 +148 @@
  * Destroys an HDA stream.
  *
- * @param   pStream             HDA stream to destroy.
- */
-void hdaR3StreamDestroy(PHDASTREAM pStream)
-{
-    AssertPtrReturnVoid(pStream);
-
-    LogFlowFunc(("[SD%RU8] Destroying ...\n", pStream->u8SD));
-
-    hdaR3StreamMapDestroy(&pStream->State.Mapping);
+ * @param   pStreamShared       The HDA stream to destroy - shared bits.
+ * @param   pStreamR3           The HDA stream to destroy - ring-3 bits.
+ */
+void hdaR3StreamDestroy(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3)
+{
+    LogFlowFunc(("[SD%RU8] Destroying ...\n", pStreamShared->u8SD));
+
+    hdaR3StreamMapDestroy(&pStreamR3->State.Mapping);
 
     int rc2;
 
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    rc2 = hdaR3StreamAsyncIODestroy(pStream);
+    rc2 = hdaR3StreamAsyncIODestroy(pStreamR3);
     AssertRC(rc2);
 #endif
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    if (RTCritSectIsInitialized(&pStream->CritSect))
-    {
-        rc2 = RTCritSectDelete(&pStream->CritSect);
+    if (RTCritSectIsInitialized(&pStreamR3->CritSect))
+    {
+        rc2 = RTCritSectDelete(&pStreamR3->CritSect);
         AssertRC(rc2);
     }
 # endif
 
-    if (pStream->State.pCircBuf)
-    {
-        RTCircBufDestroy(pStream->State.pCircBuf);
-        pStream->State.pCircBuf = NULL;
-    }
-
-    hdaR3StreamPeriodDestroy(&pStream->State.Period);
+    if (pStreamR3->State.pCircBuf)
+    {
+        RTCircBufDestroy(pStreamR3->State.pCircBuf);
+        pStreamR3->State.pCircBuf = NULL;
+    }
+
+    hdaR3StreamPeriodDestroy(&pStreamShared->State.Period);
 
 #ifdef DEBUG
-    if (RTCritSectIsInitialized(&pStream->Dbg.CritSect))
-    {
-        rc2 = RTCritSectDelete(&pStream->Dbg.CritSect);
+    if (RTCritSectIsInitialized(&pStreamR3->Dbg.CritSect))
+    {
+        rc2 = RTCritSectDelete(&pStreamR3->Dbg.CritSect);
         AssertRC(rc2);
     }
 #endif
 
-    if (pStream->Dbg.Runtime.fEnabled)
-    {
-        DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileStream);
-        pStream->Dbg.Runtime.pFileStream = NULL;
-
-        DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMARaw);
-        pStream->Dbg.Runtime.pFileDMARaw = NULL;
-
-        DrvAudioHlpFileDestroy(pStream->Dbg.Runtime.pFileDMAMapped);
-        pStream->Dbg.Runtime.pFileDMAMapped = NULL;
+    if (pStreamR3->Dbg.Runtime.fEnabled)
+    {
+        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileStream);
+        pStreamR3->Dbg.Runtime.pFileStream = NULL;
+
+        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMARaw);
+        pStreamR3->Dbg.Runtime.pFileDMARaw = NULL;
+
+        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMAMapped);
+        pStreamR3->Dbg.Runtime.pFileDMAMapped = NULL;
     }
 
@@ -189 +204 @@
 
 /**
- * Initializes an HDA stream.
- *
- * @returns IPRT status code. VINF_NO_CHANGE if the stream does not need (re-)initialization because the stream's (hardware)
- *          parameters did not change.
- * @param   pDevIns The device instance.
- * @param   pStream HDA stream to initialize.
- * @param   uSD     SD (stream descriptor) number to assign the HDA stream to.
- */
-int hdaR3StreamInit(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint8_t uSD)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    PHDASTATE pThis = pStream->pHDAState;
-    AssertPtr(pThis);
+ * Sets up ((re-)iniitalizes) an HDA stream.
+ *
+ * @returns IPRT status code. VINF_NO_CHANGE if the stream does not need
+ *          be set-up again because the stream's (hardware) parameters did
+ *          not change.
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The shared HDA device state (for HW register
+ *                          parameters).
+ * @param   pStreamShared   HDA stream to set up, shared portion.
+ * @param   pStreamR3       HDA stream to set up, ring-3 portion.
+ * @param   uSD             Stream descriptor number to assign it.
+ */
+int hdaR3StreamSetUp(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, uint8_t uSD)
+{
+    /* These member can only change on data corruption, despite what the code does further down (bird).  */
+    Assert(pStreamShared->u8SD == uSD);
+    Assert(pStreamR3->u8SD     == uSD);
 
     const uint64_t u64BDLBase = RT_MAKE_U64(HDA_STREAM_REG(pThis, BDPL, uSD),
@@ -232 +250 @@
 
     /* Reset (any former) stream map. */
-    hdaR3StreamMapReset(&pStream->State.Mapping);
+    hdaR3StreamMapReset(&pStreamR3->State.Mapping);
 
     /*
@@ -242 +260 @@
      * number of channels in a single audio stream.
      */
-    rc = hdaR3StreamMapInit(&pStream->State.Mapping, &Props);
+    rc = hdaR3StreamMapInit(&pStreamR3->State.Mapping, &Props);
     AssertRCReturn(rc, rc);
 
-    ASSERT_GUEST_LOGREL_MSG_RETURN(u32CBL % pStream->State.Mapping.cbFrameSize == 0,
-                                   ("CBL for stream #%RU8 does not align to frame size\n", pStream->u8SD),
+    ASSERT_GUEST_LOGREL_MSG_RETURN(   pStreamR3->State.Mapping.cbFrameSize > 0
+                                   && u32CBL % pStreamR3->State.Mapping.cbFrameSize == 0,
+                                   ("CBL for stream #%RU8 does not align to frame size (u32CBL=%u cbFrameSize=%u)\n",
+                                    uSD, u32CBL, pStreamR3->State.Mapping.cbFrameSize),
                                    VERR_INVALID_PARAMETER);
 
@@ -258 +278 @@
     {
         if (Props.cChannels >= 5)
-            pStream->State.uTimerHz = 300;
+            pStreamShared->State.uTimerHz = 300;
         else if (Props.cChannels == 4)
-            pStream->State.uTimerHz = 150;
+            pStreamShared->State.uTimerHz = 150;
         else
-            pStream->State.uTimerHz = 100;
+            pStreamShared->State.uTimerHz = 100;
     }
     else
-        pStream->State.uTimerHz = pThis->uTimerHz;
+        pStreamShared->State.uTimerHz = pThis->uTimerHz;
 
 #ifndef VBOX_WITH_AUDIO_HDA_51_SURROUND
@@ -286 +306 @@
      * If not, we can skip a lot of the (re-)initialization and just (re-)use the existing stuff.
      * Also, tell the caller so that further actions can be taken. */
-    if (   uSD        == pStream->u8SD
-        && u64BDLBase == pStream->u64BDLBase
-        && u16LVI     == pStream->u16LVI
-        && u32CBL     == pStream->u32CBL
-        && u16FIFOS   == pStream->u16FIFOS
-        && u16FMT     == pStream->u16FMT)
+    if (   uSD        == pStreamShared->u8SD   /* paranoia OFC */
+        && u64BDLBase == pStreamShared->u64BDLBase
+        && u16LVI     == pStreamShared->u16LVI
+        && u32CBL     == pStreamShared->u32CBL
+        && u16FIFOS   == pStreamShared->u16FIFOS
+        && u16FMT     == pStreamShared->u16FMT)
     {
         LogFunc(("[SD%RU8] No format change, skipping (re-)initialization\n", uSD));
@@ -297 +317 @@
     }
 
-    pStream->u8SD       = uSD;
+    pStreamShared->u8SD       = uSD;
 
     /* Update all register copies so that we later know that something has changed. */
-    pStream->u64BDLBase = u64BDLBase;
-    pStream->u16LVI     = u16LVI;
-    pStream->u32CBL     = u32CBL;
-    pStream->u16FIFOS   = u16FIFOS;
-    pStream->u16FMT     = u16FMT;
-
-    PPDMAUDIOSTREAMCFG pCfg = &pStream->State.Cfg;
+    pStreamShared->u64BDLBase = u64BDLBase;
+    pStreamShared->u16LVI     = u16LVI;
+    pStreamShared->u32CBL     = u32CBL;
+    pStreamShared->u16FIFOS   = u16FIFOS;
+    pStreamShared->u16FMT     = u16FMT;
+
+    PPDMAUDIOSTREAMCFG pCfg = &pStreamShared->State.Cfg;
     pCfg->Props = Props;
 
     /* (Re-)Allocate the stream's internal DMA buffer, based on the PCM  properties we just got above. */
-    if (pStream->State.pCircBuf)
-    {
-        RTCircBufDestroy(pStream->State.pCircBuf);
-        pStream->State.pCircBuf = NULL;
+    if (pStreamR3->State.pCircBuf)
+    {
+        RTCircBufDestroy(pStreamR3->State.pCircBuf);
+        pStreamR3->State.pCircBuf = NULL;
     }
 
     /* By default we allocate an internal buffer of 100ms. */
-    rc = RTCircBufCreate(&pStream->State.pCircBuf,
+    rc = RTCircBufCreate(&pStreamR3->State.pCircBuf,
                          DrvAudioHlpMilliToBytes(100 /* ms */, &pCfg->Props)); /** @todo Make this configurable. */
     AssertRCReturn(rc, rc);
 
     /* Set the stream's direction. */
-    pCfg->enmDir = hdaGetDirFromSD(pStream->u8SD);
+    pCfg->enmDir = hdaGetDirFromSD(uSD);
 
     /* The the stream's name, based on the direction. */
@@ -348 +368 @@
 
     /* Set scheduling hint (if available). */
-    if (pStream->State.uTimerHz)
-        pCfg->Device.cMsSchedulingHint = 1000 /* ms */ / pStream->State.uTimerHz;
+    if (pStreamShared->State.uTimerHz)
+        pCfg->Device.cMsSchedulingHint = 1000 /* ms */ / pStreamShared->State.uTimerHz;
 
     LogFunc(("[SD%RU8] DMA @ 0x%x (%RU32 bytes), LVI=%RU16, FIFOS=%RU16\n",
-             pStream->u8SD, pStream->u64BDLBase, pStream->u32CBL, pStream->u16LVI, pStream->u16FIFOS));
+             uSD, pStreamShared->u64BDLBase, pStreamShared->u32CBL, pStreamShared->u16LVI, pStreamShared->u16FIFOS));
 
     if (RT_SUCCESS(rc))
     {
         /* Make sure that the chosen Hz rate dividable by the stream's rate. */
-        if (pStream->State.Cfg.Props.uHz % pStream->State.uTimerHz != 0)
+        if (pStreamShared->State.Cfg.Props.uHz % pStreamShared->State.uTimerHz != 0)
             LogRel(("HDA: Stream timer Hz rate (%RU32) does not fit to stream #%RU8 timing (%RU32)\n",
-                    pStream->State.uTimerHz, pStream->u8SD, pStream->State.Cfg.Props.uHz));
+                    pStreamShared->State.uTimerHz, uSD, pStreamShared->State.Cfg.Props.uHz));
 
         /* Figure out how many transfer fragments we're going to use for this stream. */
         /** @todo Use a more dynamic fragment size? */
-        uint8_t cFragments = pStream->u16LVI + 1;
+        uint8_t cFragments = pStreamShared->u16LVI + 1;
         if (cFragments <= 1)
             cFragments = 2; /* At least two fragments (BDLEs) must be present. */
@@ -373 +393 @@
 
         LogFunc(("[SD%RU8] fPosAdjustEnabled=%RTbool, cPosAdjustFrames=%RU16\n",
-                 pStream->u8SD, pThis->fPosAdjustEnabled, pThis->cPosAdjustFrames));
+                 uSD, pThis->fPosAdjustEnabled, pThis->cPosAdjustFrames));
 
         if (pThis->fPosAdjustEnabled) /* Is the position adjustment enabled at all? */
@@ -380 +400 @@
             RT_ZERO(BDLE);
 
-            int rc2 = hdaR3BDLEFetch(pThis, &BDLE, pStream->u64BDLBase, 0 /* Entry */);
+            int rc2 = hdaR3BDLEFetch(pDevIns, &BDLE, pStreamShared->u64BDLBase, 0 /* Entry */);
             AssertRC(rc2);
 
@@ -400 +420 @@
 #ifdef VBOX_WITH_INTEL_HDA
                 /* Intel ICH / PCH: 1 frame. */
-                if (BDLE.Desc.u32BufSize == (uint32_t)(1 * pStream->State.Mapping.cbFrameSize))
+                if (BDLE.Desc.u32BufSize == (uint32_t)(1 * pStreamR3->State.Mapping.cbFrameSize))
                 {
                     cfPosAdjust = 1;
                 }
                 /* Intel Baytrail / Braswell: 32 frames. */
-                else if (BDLE.Desc.u32BufSize == (uint32_t)(32 * pStream->State.Mapping.cbFrameSize))
+                else if (BDLE.Desc.u32BufSize == (uint32_t)(32 * pStreamR3->State.Mapping.cbFrameSize))
                 {
                     cfPosAdjust = 32;
@@ -426 +446 @@
                  * position adjustment.
                  */
-                if (   (cfPosAdjust * pStream->State.Mapping.cbFrameSize) == BDLE.Desc.u32BufSize
+                if (   (cfPosAdjust * pStreamR3->State.Mapping.cbFrameSize) == BDLE.Desc.u32BufSize
                     && cFragments)
                 {
@@ -433 +453 @@
 
                 /* Initialize position adjustment counter. */
-                pStream->State.cfPosAdjustDefault = cfPosAdjust;
-                pStream->State.cfPosAdjustLeft    = pStream->State.cfPosAdjustDefault;
+                pStreamShared->State.cfPosAdjustDefault = cfPosAdjust;
+                pStreamShared->State.cfPosAdjustLeft    = pStreamShared->State.cfPosAdjustDefault;
 
                 LogRel2(("HDA: Position adjustment for stream #%RU8 active (%RU32 frames)\n",
-                         pStream->u8SD, pStream->State.cfPosAdjustDefault));
+                         uSD, pStreamShared->State.cfPosAdjustDefault));
             }
         }
 
-        LogFunc(("[SD%RU8] cfPosAdjust=%RU32, cFragments=%RU8\n", pStream->u8SD, cfPosAdjust, cFragments));
+        LogFunc(("[SD%RU8] cfPosAdjust=%RU32, cFragments=%RU8\n", uSD, cfPosAdjust, cFragments));
 
         /*
@@ -448 +468 @@
 
         /* Calculate the fragment size the guest OS expects interrupt delivery at. */
-        pStream->State.cbTransferSize = pStream->u32CBL / cFragments;
-        Assert(pStream->State.cbTransferSize);
-        Assert(pStream->State.cbTransferSize % pStream->State.Mapping.cbFrameSize == 0);
-        ASSERT_GUEST_LOGREL_MSG_STMT(pStream->State.cbTransferSize,
-                                     ("Transfer size for stream #%RU8 is invalid\n", pStream->u8SD), rc = VERR_INVALID_PARAMETER);
+        pStreamShared->State.cbTransferSize = pStreamShared->u32CBL / cFragments;
+        Assert(pStreamShared->State.cbTransferSize);
+        Assert(pStreamShared->State.cbTransferSize % pStreamR3->State.Mapping.cbFrameSize == 0);
+        ASSERT_GUEST_LOGREL_MSG_STMT(pStreamShared->State.cbTransferSize,
+                                     ("Transfer size for stream #%RU8 is invalid\n", uSD), rc = VERR_INVALID_PARAMETER);
         if (RT_SUCCESS(rc))
         {
             /* Calculate the bytes we need to transfer to / from the stream's DMA per iteration.
              * This is bound to the device's Hz rate and thus to the (virtual) timing the device expects. */
-            pStream->State.cbTransferChunk = (pStream->State.Cfg.Props.uHz / pStream->State.uTimerHz) * pStream->State.Mapping.cbFrameSize;
-            Assert(pStream->State.cbTransferChunk);
-            Assert(pStream->State.cbTransferChunk % pStream->State.Mapping.cbFrameSize == 0);
-            ASSERT_GUEST_LOGREL_MSG_STMT(pStream->State.cbTransferChunk,
-                                         ("Transfer chunk for stream #%RU8 is invalid\n", pStream->u8SD),
+            pStreamShared->State.cbTransferChunk = (pStreamShared->State.Cfg.Props.uHz / pStreamShared->State.uTimerHz) * pStreamR3->State.Mapping.cbFrameSize;
+            Assert(pStreamShared->State.cbTransferChunk);
+            Assert(pStreamShared->State.cbTransferChunk % pStreamR3->State.Mapping.cbFrameSize == 0);
+            ASSERT_GUEST_LOGREL_MSG_STMT(pStreamShared->State.cbTransferChunk,
+                                         ("Transfer chunk for stream #%RU8 is invalid\n", uSD),
                                          rc = VERR_INVALID_PARAMETER);
             if (RT_SUCCESS(rc))
             {
                 /* Make sure that the transfer chunk does not exceed the overall transfer size. */
-                if (pStream->State.cbTransferChunk > pStream->State.cbTransferSize)
-                    pStream->State.cbTransferChunk = pStream->State.cbTransferSize;
-
-                const uint64_t cTicksPerHz = PDMDevHlpTimerGetFreq(pDevIns, pStream->hTimer) / pStream->State.uTimerHz;
+                if (pStreamShared->State.cbTransferChunk > pStreamShared->State.cbTransferSize)
+                    pStreamShared->State.cbTransferChunk = pStreamShared->State.cbTransferSize;
+
+                const uint64_t cTicksPerHz = PDMDevHlpTimerGetFreq(pDevIns, pStreamShared->hTimer) / pStreamShared->State.uTimerHz;
 
                 /* Calculate the timer ticks per byte for this stream. */
-                pStream->State.cTicksPerByte = cTicksPerHz / pStream->State.cbTransferChunk;
-                Assert(pStream->State.cTicksPerByte);
+                pStreamShared->State.cTicksPerByte = cTicksPerHz / pStreamShared->State.cbTransferChunk;
+                Assert(pStreamShared->State.cTicksPerByte);
 
                 /* Calculate timer ticks per transfer. */
-                pStream->State.cTransferTicks = pStream->State.cbTransferChunk * pStream->State.cTicksPerByte;
-                Assert(pStream->State.cTransferTicks);
+                pStreamShared->State.cTransferTicks = pStreamShared->State.cbTransferChunk * pStreamShared->State.cTicksPerByte;
+                Assert(pStreamShared->State.cTransferTicks);
 
                 LogFunc(("[SD%RU8] Timer %uHz (%RU64 ticks per Hz), cTicksPerByte=%RU64, cbTransferChunk=%RU32, " \
                          "cTransferTicks=%RU64, cbTransferSize=%RU32\n",
-                         pStream->u8SD, pStream->State.uTimerHz, cTicksPerHz, pStream->State.cTicksPerByte,
-                         pStream->State.cbTransferChunk, pStream->State.cTransferTicks, pStream->State.cbTransferSize));
+                         uSD, pStreamShared->State.uTimerHz, cTicksPerHz, pStreamShared->State.cTicksPerByte,
+                         pStreamShared->State.cbTransferChunk, pStreamShared->State.cTransferTicks, pStreamShared->State.cbTransferSize));
 
                 /* Make sure to also update the stream's DMA counter (based on its current LPIB value). */
-                hdaR3StreamSetPosition(pStream, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD));
+                hdaR3StreamSetPosition(pStreamShared, pDevIns, pThis, HDA_STREAM_REG(pThis, LPIB, uSD));
 
 #ifdef LOG_ENABLED
-                hdaR3BDLEDumpAll(pThis, pStream->u64BDLBase, pStream->u16LVI + 1);
+                hdaR3BDLEDumpAll(pDevIns, pThis, pStreamShared->u64BDLBase, pStreamShared->u16LVI + 1);
 #endif
             }
@@ -495 +515 @@
 
     if (RT_FAILURE(rc))
-        LogRel(("HDA: Initializing stream #%RU8 failed with %Rrc\n", pStream->u8SD, rc));
+        LogRel(("HDA: Initializing stream #%RU8 failed with %Rrc\n", uSD, rc));
 
     return rc;
@@ -503 +523 @@
  * Resets an HDA stream.
  *
- * @param   pThis               HDA state.
- * @param   pStream             HDA stream to reset.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
+ * @param   pStreamShared       HDA stream to reset (shared).
+ * @param   pStreamR3           HDA stream to reset (ring-3).
  * @param   uSD                 Stream descriptor (SD) number to use for this stream.
  */
-void hdaR3StreamReset(PHDASTATE pThis, PHDASTREAM pStream, uint8_t uSD)
-{
-    AssertPtrReturnVoid(pThis);
-    AssertPtrReturnVoid(pStream);
-    AssertReturnVoid(uSD < HDA_MAX_STREAMS);
-
-# ifdef VBOX_STRICT
-    AssertReleaseMsg(!pStream->State.fRunning, ("[SD%RU8] Cannot reset stream while in running state\n", uSD));
-# endif
+void hdaR3StreamReset(PHDASTATE pThis, PHDASTATER3 pThisCC, PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, uint8_t uSD)
+{
+    AssertPtr(pThis);
+    AssertPtr(pStreamShared);
+    AssertPtr(pStreamR3);
+    Assert(uSD < HDA_MAX_STREAMS);
+    AssertMsg(!pStreamShared->State.fRunning, ("[SD%RU8] Cannot reset stream while in running state\n", uSD));
 
     LogFunc(("[SD%RU8] Reset\n", uSD));
@@ -522 +542 @@
      * Set reset state.
      */
-    Assert(ASMAtomicReadBool(&pStream->State.fInReset) == false); /* No nested calls. */
-    ASMAtomicXchgBool(&pStream->State.fInReset, true);
+    Assert(ASMAtomicReadBool(&pStreamShared->State.fInReset) == false); /* No nested calls. */
+    ASMAtomicXchgBool(&pStreamShared->State.fInReset, true);
 
     /*
@@ -548 +568 @@
 
     /* Assign the default mixer sink to the stream. */
-    pStream->pMixSink = hdaR3GetDefaultSink(pThis, uSD);
+    pStreamR3->pMixSink = hdaR3GetDefaultSink(pThisCC, uSD);
 
     /* Reset position adjustment counter. */
-    pStream->State.cfPosAdjustLeft = pStream->State.cfPosAdjustDefault;
+    pStreamShared->State.cfPosAdjustLeft = pStreamShared->State.cfPosAdjustDefault;
 
     /* Reset transfer stuff. */
-    pStream->State.cbTransferProcessed        = 0;
-    pStream->State.cTransferPendingInterrupts = 0;
-    pStream->State.tsTransferLast = 0;
-    pStream->State.tsTransferNext = 0;
+    pStreamShared->State.cbTransferProcessed        = 0;
+    pStreamShared->State.cTransferPendingInterrupts = 0;
+    pStreamShared->State.tsTransferLast = 0;
+    pStreamShared->State.tsTransferNext = 0;
 
     /* Initialize other timestamps. */
-    pStream->State.tsLastUpdateNs = 0;
-
-    RT_ZERO(pStream->State.BDLE);
-    pStream->State.uCurBDLE = 0;
-
-    if (pStream->State.pCircBuf)
-        RTCircBufReset(pStream->State.pCircBuf);
+    pStreamShared->State.tsLastUpdateNs = 0;
+
+    RT_ZERO(pStreamShared->State.BDLE);
+    pStreamShared->State.uCurBDLE = 0;
+
+    if (pStreamR3->State.pCircBuf)
+        RTCircBufReset(pStreamR3->State.pCircBuf);
 
     /* Reset the stream's period. */
-    hdaR3StreamPeriodReset(&pStream->State.Period);
+    hdaR3StreamPeriodReset(&pStreamShared->State.Period);
 
 #ifdef DEBUG
-    pStream->Dbg.cReadsTotal      = 0;
-    pStream->Dbg.cbReadTotal      = 0;
-    pStream->Dbg.tsLastReadNs     = 0;
-    pStream->Dbg.cWritesTotal     = 0;
-    pStream->Dbg.cbWrittenTotal   = 0;
-    pStream->Dbg.cWritesHz        = 0;
-    pStream->Dbg.cbWrittenHz      = 0;
-    pStream->Dbg.tsWriteSlotBegin = 0;
+    pStreamR3->Dbg.cReadsTotal      = 0;
+    pStreamR3->Dbg.cbReadTotal      = 0;
+    pStreamR3->Dbg.tsLastReadNs     = 0;
+    pStreamR3->Dbg.cWritesTotal     = 0;
+    pStreamR3->Dbg.cbWrittenTotal   = 0;
+    pStreamR3->Dbg.cWritesHz        = 0;
+    pStreamR3->Dbg.cbWrittenHz      = 0;
+    pStreamR3->Dbg.tsWriteSlotBegin = 0;
 #endif
 
@@ -588 +608 @@
 
     /* Exit reset mode. */
-    ASMAtomicXchgBool(&pStream->State.fInReset, false);
+    ASMAtomicXchgBool(&pStreamShared->State.fInReset, false);
 }
 
@@ -595 +615 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to enable or disable.
+ * @param   pStreamShared       HDA stream to enable or disable - shared bits.
+ * @param   pStreamR3           HDA stream to enable or disable - ring-3 bits.
  * @param   fEnable             Whether to enable or disble the stream.
  */
-int hdaR3StreamEnable(PHDASTREAM pStream, bool fEnable)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    LogFunc(("[SD%RU8] fEnable=%RTbool, pMixSink=%p\n", pStream->u8SD, fEnable, pStream->pMixSink));
+int hdaR3StreamEnable(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, bool fEnable)
+{
+    AssertPtr(pStreamR3);
+    AssertPtr(pStreamShared);
+
+    LogFunc(("[SD%RU8] fEnable=%RTbool, pMixSink=%p\n", pStreamShared->u8SD, fEnable, pStreamR3->pMixSink));
 
     int rc = VINF_SUCCESS;
@@ -610 +632 @@
 
     /* First, enable or disable the stream and the stream's sink, if any. */
-    if (   pStream->pMixSink
-        && pStream->pMixSink->pMixSink)
-        rc = AudioMixerSinkCtl(pStream->pMixSink->pMixSink, enmCmd);
+    if (   pStreamR3->pMixSink
+        && pStreamR3->pMixSink->pMixSink)
+        rc = AudioMixerSinkCtl(pStreamR3->pMixSink->pMixSink, enmCmd);
 
     if (   RT_SUCCESS(rc)
         && fEnable
-        && pStream->Dbg.Runtime.fEnabled)
-    {
-        Assert(DrvAudioHlpPCMPropsAreValid(&pStream->State.Cfg.Props));
+        && pStreamR3->Dbg.Runtime.fEnabled)
+    {
+        Assert(DrvAudioHlpPCMPropsAreValid(&pStreamShared->State.Cfg.Props));
 
         if (fEnable)
         {
-            if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileStream))
-            {
-                int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStream->State.Cfg.Props);
+            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileStream))
+            {
+                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                              &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
 
-            if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMARaw))
-            {
-                int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMARaw, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStream->State.Cfg.Props);
+            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMARaw))
+            {
+                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMARaw, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                              &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
 
-            if (!DrvAudioHlpFileIsOpen(pStream->Dbg.Runtime.pFileDMAMapped))
-            {
-                int rc2 = DrvAudioHlpFileOpen(pStream->Dbg.Runtime.pFileDMAMapped, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStream->State.Cfg.Props);
+            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped))
+            {
+                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                              &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
@@ -647 +669 @@
     if (RT_SUCCESS(rc))
     {
-        pStream->State.fRunning = fEnable;
-    }
-
-    LogFunc(("[SD%RU8] rc=%Rrc\n", pStream->u8SD, rc));
+        pStreamShared->State.fRunning = fEnable;
+    }
+
+    LogFunc(("[SD%RU8] rc=%Rrc\n", pStreamShared->u8SD, rc));
     return rc;
 }
 
-uint32_t hdaR3StreamGetPosition(PHDASTATE pThis, PHDASTREAM pStream)
-{
-    return HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
-}
-
-/**
+static uint32_t hdaR3StreamGetPosition(PHDASTATE pThis, PHDASTREAM pStreamShared)
+{
+    return HDA_STREAM_REG(pThis, LPIB, pStreamShared->u8SD);
+}
+
+/*
  * Updates an HDA stream's current read or write buffer position (depending on the stream type) by
  * updating its associated LPIB register and DMA position buffer (if enabled).
  *
- * @param   pStream             HDA stream to update read / write position for.
+ * @param   pStreamShared       HDA stream to update read / write position for (shared).
+ * @param   pDevIns             The device instance.
+ * @param   pThis               The shared HDA device state.
  * @param   u32LPIB             Absolute position (in bytes) to set current read / write position to.
  */
-void hdaR3StreamSetPosition(PHDASTREAM pStream, uint32_t u32LPIB)
-{
-    AssertPtrReturnVoid(pStream);
-
-    Log3Func(("[SD%RU8] LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",
-              pStream->u8SD, u32LPIB, pStream->pHDAState->fDMAPosition));
+static void hdaR3StreamSetPosition(PHDASTREAM pStreamShared, PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t u32LPIB)
+{
+    AssertPtrReturnVoid(pStreamShared);
+
+    Log3Func(("[SD%RU8] LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",  pStreamShared->u8SD, u32LPIB, pThis->fDMAPosition));
 
     /* Update LPIB in any case. */
-    HDA_STREAM_REG(pStream->pHDAState, LPIB, pStream->u8SD) = u32LPIB;
+    HDA_STREAM_REG(pThis, LPIB, pStreamShared->u8SD) = u32LPIB;
 
     /* Do we need to tell the current DMA position? */
-    if (pStream->pHDAState->fDMAPosition)
-    {
-        int rc2 = PDMDevHlpPCIPhysWrite(pStream->pHDAState->CTX_SUFF(pDevIns),
-                                        pStream->pHDAState->u64DPBase + (pStream->u8SD * 2 * sizeof(uint32_t)),
+    if (pThis->fDMAPosition)
+    {
+        int rc2 = PDMDevHlpPCIPhysWrite(pDevIns,
+                                        pThis->u64DPBase + (pStreamShared->u8SD * 2 * sizeof(uint32_t)),
                                         (void *)&u32LPIB, sizeof(uint32_t));
         AssertRC(rc2);
@@ -690 +713 @@
  *
  * @returns Available data (in bytes).
- * @param   pStream             HDA stream to retrieve size for.
- */
-uint32_t hdaR3StreamGetUsed(PHDASTREAM pStream)
-{
-    AssertPtrReturn(pStream, 0);
-
-    if (!pStream->State.pCircBuf)
-        return 0;
-
-    return (uint32_t)RTCircBufUsed(pStream->State.pCircBuf);
+ * @param   pStreamR3           HDA stream to retrieve size for (ring-3).
+ */
+static uint32_t hdaR3StreamGetUsed(PHDASTREAMR3 pStreamR3)
+{
+    AssertPtrReturn(pStreamR3, 0);
+
+    if (pStreamR3->State.pCircBuf)
+        return (uint32_t)RTCircBufUsed(pStreamR3->State.pCircBuf);
+    return 0;
 }
 
@@ -706 +728 @@
  *
  * @returns Free data (in bytes).
- * @param   pStream             HDA stream to retrieve size for.
- */
-uint32_t hdaR3StreamGetFree(PHDASTREAM pStream)
-{
-    AssertPtrReturn(pStream, 0);
-
-    if (!pStream->State.pCircBuf)
-        return 0;
-
-    return (uint32_t)RTCircBufFree(pStream->State.pCircBuf);
+ * @param   pStreamR3           HDA stream to retrieve size for (ring-3).
+ */
+static uint32_t hdaR3StreamGetFree(PHDASTREAMR3 pStreamR3)
+{
+    AssertPtrReturn(pStreamR3, 0);
+
+    if (pStreamR3->State.pCircBuf)
+        return (uint32_t)RTCircBufFree(pStreamR3->State.pCircBuf);
+    return 0;
 }
 
@@ -725 +746 @@
  *
  * @returns True if a next transfer is scheduled, false if not.
- * @param   pStream             HDA stream to retrieve schedule status for.
+ * @param   pStreamShared       HDA stream to retrieve schedule status for (shared).
  * @param   tsNow               The current time.
  */
-bool hdaR3StreamTransferIsScheduled(PHDASTREAM pStream, uint64_t tsNow)
-{
-    if (pStream)
-    {
-        AssertPtrReturn(pStream->pHDAState, false);
-
-        if (pStream->State.fRunning)
-        {
-            if (pStream->State.cTransferPendingInterrupts)
-            {
-                Log3Func(("[SD%RU8] Scheduled (%RU8 IRQs pending)\n", pStream->u8SD, pStream->State.cTransferPendingInterrupts));
+bool hdaR3StreamTransferIsScheduled(PHDASTREAM pStreamShared, uint64_t tsNow)
+{
+    if (pStreamShared)
+    {
+        if (pStreamShared->State.fRunning)
+        {
+            if (pStreamShared->State.cTransferPendingInterrupts)
+            {
+                Log3Func(("[SD%RU8] Scheduled (%RU8 IRQs pending)\n", pStreamShared->u8SD, pStreamShared->State.cTransferPendingInterrupts));
                 return true;
             }
 
-            if (pStream->State.tsTransferNext > tsNow)
-            {
-                Log3Func(("[SD%RU8] Scheduled in %RU64\n", pStream->u8SD, pStream->State.tsTransferNext - tsNow));
+            if (pStreamShared->State.tsTransferNext > tsNow)
+            {
+                Log3Func(("[SD%RU8] Scheduled in %RU64\n", pStreamShared->u8SD, pStreamShared->State.tsTransferNext - tsNow));
                 return true;
             }
@@ -757 +776 @@
  *
  * @returns The (virtual) clock timestamp of the next transfer.
- * @param   pStream             HDA stream to retrieve timestamp for.
- */
-uint64_t hdaR3StreamTransferGetNext(PHDASTREAM pStream)
-{
-    return pStream->State.tsTransferNext;
+ * @param   pStreamShared       HDA stream to retrieve timestamp for (shared).
+ */
+uint64_t hdaR3StreamTransferGetNext(PHDASTREAM pStreamShared)
+{
+    return pStreamShared->State.tsTransferNext;
 }
 
@@ -768 +787 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to write to.
+ * @param   pStreamR3           HDA stream to write to (ring-3).
  * @param   pvBuf               Data buffer to write.
  *                              If NULL, silence will be written.
@@ -774 +793 @@
  * @param   pcbWritten          Number of bytes written. Optional.
  */
-int hdaR3StreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    /* pvBuf is optional. */
-    AssertReturn(cbBuf,      VERR_INVALID_PARAMETER);
-    /* pcbWritten is optional. */
-
-    PRTCIRCBUF pCircBuf = pStream->State.pCircBuf;
+static int hdaR3StreamWrite(PHDASTREAMR3 pStreamR3, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten)
+{
+    Assert(cbBuf);
+
+    PRTCIRCBUF pCircBuf = pStreamR3->State.pCircBuf;
     AssertPtr(pCircBuf);
-
-    int rc = VINF_SUCCESS;
 
     uint32_t cbWrittenTotal = 0;
@@ -793 +807 @@
         void *pvDst;
         size_t cbDst;
-
         RTCircBufAcquireWriteBlock(pCircBuf, cbLeft, &pvDst, &cbDst);
 
@@ -799 +812 @@
         {
             if (pvBuf)
-            {
                 memcpy(pvDst, (uint8_t *)pvBuf + cbWrittenTotal, cbDst);
-            }
             else /* Send silence. */
             {
@@ -809 +820 @@
             }
 
-            if (pStream->Dbg.Runtime.fEnabled)
-                DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileStream, pvDst, cbDst, 0 /* fFlags */);
+            if (RT_LIKELY(!pStreamR3->Dbg.Runtime.fEnabled))
+            { /* likely */ }
+            else
+                DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, pvDst, cbDst, 0 /* fFlags */);
         }
 
         RTCircBufReleaseWriteBlock(pCircBuf, cbDst);
-
-        if (RT_FAILURE(rc))
-            break;
 
         Assert(cbLeft  >= (uint32_t)cbDst);
         cbLeft         -= (uint32_t)cbDst;
-
         cbWrittenTotal += (uint32_t)cbDst;
     }
@@ -829 +838 @@
         *pcbWritten = cbWrittenTotal;
 
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -837 +846 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to read audio data from.
+ * @param   pStreamR3           HDA stream to read audio data from (ring-3).
  * @param   cbToRead            Number of bytes to read.
  * @param   pcbRead             Number of bytes read. Optional.
  */
-int hdaR3StreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-    AssertReturn(cbToRead,   VERR_INVALID_PARAMETER);
-    /* pcbWritten is optional. */
-
-    PHDAMIXERSINK pSink = pStream->pMixSink;
-    if (!pSink)
-    {
-        AssertMsgFailed(("[SD%RU8] Can't read from a stream with no sink attached\n", pStream->u8SD));
-
-        if (pcbRead)
-            *pcbRead = 0;
-        return VINF_SUCCESS;
-    }
-
-    PRTCIRCBUF pCircBuf = pStream->State.pCircBuf;
+static int hdaR3StreamRead(PHDASTREAMR3 pStreamR3, uint32_t cbToRead, uint32_t *pcbRead)
+{
+    Assert(cbToRead);
+
+    PHDAMIXERSINK pSink = pStreamR3->pMixSink;
+    AssertMsgReturnStmt(pSink, ("[SD%RU8] Can't read from a stream with no sink attached\n", pStreamR3->u8SD),
+                        if (pcbRead) *pcbRead = 0,
+                        VINF_SUCCESS);
+
+    PRTCIRCBUF pCircBuf = pStreamR3->State.pCircBuf;
     AssertPtr(pCircBuf);
 
@@ -876 +878 @@
         if (cbSrc)
         {
-            if (pStream->Dbg.Runtime.fEnabled)
-                DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileStream, pvSrc, cbSrc, 0 /* fFlags */);
+            if (pStreamR3->Dbg.Runtime.fEnabled)
+                DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, pvSrc, cbSrc, 0 /* fFlags */);
 
             rc = AudioMixerSinkWrite(pSink->pMixSink, AUDMIXOP_COPY, pvSrc, (uint32_t)cbSrc, &cbWritten);
@@ -883 +885 @@
 
             Assert(cbSrc >= cbWritten);
-            Log2Func(("[SD%RU8] %RU32/%zu bytes read\n", pStream->u8SD, cbWritten, cbSrc));
+            Log2Func(("[SD%RU8] %RU32/%zu bytes read\n", pStreamR3->u8SD, cbWritten, cbSrc));
         }
 
@@ -915 +917 @@
  * @returns IPRT status code.
  * @param   pDevIns             The device instance.
- * @param   pStream             HDA stream to update.
+ * @param   pThis               The shared HDA device state.
+ * @param   pThisCC             The ring-3 HDA device state.
+ * @param   pStreamShared       HDA stream to update (shared).
+ * @param   pStreamR3           HDA stream to update (ring-3).
  * @param   cbToProcessMax      How much data (in bytes) to process as maximum.
  * @param   fInTimer            Set if we're in the timer callout.
  */
-static int hdaR3StreamTransfer(PPDMDEVINS pDevIns, PHDASTREAM pStream, uint32_t cbToProcessMax, bool fInTimer)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    hdaR3StreamLock(pStream);
-
-    PHDASTATE pThis = pStream->pHDAState;
-    AssertPtr(pThis);
-
-    PHDASTREAMPERIOD pPeriod = &pStream->State.Period;
+static int hdaR3StreamTransfer(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC, PHDASTREAM pStreamShared,
+                               PHDASTREAMR3 pStreamR3, uint32_t cbToProcessMax, bool fInTimer)
+{
+    uint8_t const uSD = pStreamShared->u8SD;
+    hdaR3StreamLock(pStreamR3);
+
+    PHDASTREAMPERIOD pPeriod = &pStreamShared->State.Period;
     hdaR3StreamPeriodLock(pPeriod);
 
@@ -934 +936 @@
 
     /* Stream not running? */
-    if (!pStream->State.fRunning)
-    {
-        Log3Func(("[SD%RU8] Not running\n", pStream->u8SD));
+    if (!pStreamShared->State.fRunning)
+    {
+        Log3Func(("[SD%RU8] Not running\n", uSD));
         fProceed = false;
     }
-    else if (HDA_STREAM_REG(pThis, STS, pStream->u8SD) & HDA_SDSTS_BCIS)
-    {
-        Log3Func(("[SD%RU8] BCIS bit set\n", pStream->u8SD));
+    else if (HDA_STREAM_REG(pThis, STS, uSD) & HDA_SDSTS_BCIS)
+    {
+        Log3Func(("[SD%RU8] BCIS bit set\n", uSD));
         fProceed = false;
     }
@@ -948 +950 @@
     {
         hdaR3StreamPeriodUnlock(pPeriod);
-        hdaR3StreamUnlock(pStream);
+        hdaR3StreamUnlock(pStreamR3);
         return VINF_SUCCESS;
     }
 
-    const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStream->hTimer);
-
-    if (!pStream->State.tsTransferLast)
-        pStream->State.tsTransferLast = tsNow;
+    const uint64_t tsNow = PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer);
+
+    if (!pStreamShared->State.tsTransferLast)
+        pStreamShared->State.tsTransferLast = tsNow;
 
 #ifdef DEBUG
-    const int64_t iTimerDelta = tsNow - pStream->State.tsTransferLast;
+    const int64_t iTimerDelta = tsNow - pStreamShared->State.tsTransferLast;
     Log3Func(("[SD%RU8] Time now=%RU64, last=%RU64 -> %RI64 ticks delta\n",
-              pStream->u8SD, tsNow, pStream->State.tsTransferLast, iTimerDelta));
+              uSD, tsNow, pStreamShared->State.tsTransferLast, iTimerDelta));
 #endif
 
-    pStream->State.tsTransferLast = tsNow;
+    pStreamShared->State.tsTransferLast = tsNow;
 
     /* Sanity checks. */
-    Assert(pStream->u8SD < HDA_MAX_STREAMS);
-    Assert(pStream->u64BDLBase);
-    Assert(pStream->u32CBL);
-    Assert(pStream->u16FIFOS);
+    Assert(uSD < HDA_MAX_STREAMS);
+    Assert(pStreamShared->u64BDLBase);
+    Assert(pStreamShared->u32CBL);
+    Assert(pStreamShared->u16FIFOS);
 
     /* State sanity checks. */
-    Assert(ASMAtomicReadBool(&pStream->State.fInReset) == false);
+    Assert(ASMAtomicReadBool(&pStreamShared->State.fInReset) == false);
 
     int rc = VINF_SUCCESS;
 
     /* Fetch first / next BDL entry. */
-    PHDABDLE pBDLE = &pStream->State.BDLE;
+    PHDABDLE pBDLE = &pStreamShared->State.BDLE;
     if (hdaR3BDLEIsComplete(pBDLE))
     {
-        rc = hdaR3BDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
+        rc = hdaR3BDLEFetch(pDevIns, pBDLE, pStreamShared->u64BDLBase, pStreamShared->State.uCurBDLE);
         AssertRC(rc);
     }
 
-    uint32_t cbToProcess = RT_MIN(pStream->State.cbTransferSize - pStream->State.cbTransferProcessed,
-                                  pStream->State.cbTransferChunk);
-
-    Log3Func(("[SD%RU8] cbToProcess=%RU32, cbToProcessMax=%RU32\n", pStream->u8SD, cbToProcess, cbToProcessMax));
+    uint32_t cbToProcess = RT_MIN(pStreamShared->State.cbTransferSize - pStreamShared->State.cbTransferProcessed,
+                                  pStreamShared->State.cbTransferChunk);
+
+    Log3Func(("[SD%RU8] cbToProcess=%RU32, cbToProcessMax=%RU32\n", uSD, cbToProcess, cbToProcessMax));
 
     if (cbToProcess > cbToProcessMax)
     {
-        LogFunc(("[SD%RU8] Limiting transfer (cbToProcess=%RU32, cbToProcessMax=%RU32)\n",
-                 pStream->u8SD, cbToProcess, cbToProcessMax));
+        LogFunc(("[SD%RU8] Limiting transfer (cbToProcess=%RU32, cbToProcessMax=%RU32)\n", uSD, cbToProcess, cbToProcessMax));
 
         /* Never process more than a stream currently can handle. */
@@ -1005 +1006 @@
     {
         /* Limit the chunk to the stream's FIFO size and what's left to process. */
-        uint32_t cbChunk = RT_MIN(cbLeft, pStream->u16FIFOS);
+        uint32_t cbChunk = RT_MIN(cbLeft, pStreamShared->u16FIFOS);
 
         /* Limit the chunk to the remaining data of the current BDLE. */
@@ -1012 +1013 @@
         /* If there are position adjustment frames left to be processed,
          * make sure that we process them first as a whole. */
-        if (pStream->State.cfPosAdjustLeft)
-            cbChunk = RT_MIN(cbChunk, uint32_t(pStream->State.cfPosAdjustLeft * pStream->State.Mapping.cbFrameSize));
+        if (pStreamShared->State.cfPosAdjustLeft)
+            cbChunk = RT_MIN(cbChunk, uint32_t(pStreamShared->State.cfPosAdjustLeft * pStreamR3->State.Mapping.cbFrameSize));
 
         Log3Func(("[SD%RU8] cbChunk=%RU32, cPosAdjustFramesLeft=%RU16\n",
-                  pStream->u8SD, cbChunk, pStream->State.cfPosAdjustLeft));
+                  uSD, cbChunk, pStreamShared->State.cfPosAdjustLeft));
 
         if (!cbChunk)
@@ -1022 +1023 @@
 
         uint32_t   cbDMA    = 0;
-        PRTCIRCBUF pCircBuf = pStream->State.pCircBuf;
-
-        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN) /* Input (SDI). */
+        PRTCIRCBUF pCircBuf = pStreamR3->State.pCircBuf;
+
+        if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN) /* Input (SDI). */
         {
             STAM_PROFILE_START(&pThis->StatIn, a);
@@ -1054 +1055 @@
             if (cbDMAToWrite)
             {
-                LogRel2(("HDA: FIFO underflow for stream #%RU8 (%RU32 bytes outstanding)\n", pStream->u8SD, cbDMAToWrite));
+                LogRel2(("HDA: FIFO underflow for stream #%RU8 (%RU32 bytes outstanding)\n", uSD, cbDMAToWrite));
 
                 Assert(cbChunk == cbDMAWritten + cbDMAToWrite);
@@ -1061 +1062 @@
             }
 
-            rc = hdaR3DMAWrite(pThis, pStream, abChunk, cbDMAWritten, &cbDMA /* pcbWritten */);
+            rc = hdaR3DMAWrite(pDevIns, pThis, pStreamShared, pStreamR3, abChunk, cbDMAWritten, &cbDMA /* pcbWritten */);
             if (RT_FAILURE(rc))
-                LogRel(("HDA: Writing to stream #%RU8 DMA failed with %Rrc\n", pStream->u8SD, rc));
+                LogRel(("HDA: Writing to stream #%RU8 DMA failed with %Rrc\n", uSD, rc));
 
             STAM_PROFILE_STOP(&pThis->StatIn, a);
         }
-        else if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_OUT) /* Output (SDO). */
+        else if (hdaGetDirFromSD(uSD) == PDMAUDIODIR_OUT) /* Output (SDO). */
         {
             STAM_PROFILE_START(&pThis->StatOut, a);
 
-            rc = hdaR3DMARead(pThis, pStream, abChunk, cbChunk, &cbDMA /* pcbRead */);
+            rc = hdaR3DMARead(pDevIns, pThis, pStreamShared, pStreamR3, abChunk, cbChunk, &cbDMA /* pcbRead */);
             if (RT_SUCCESS(rc))
             {
@@ -1083 +1084 @@
                  * Only macOS guests need the frame extraction branch below at the moment AFAIK.
                  */
-                if (pStream->State.Mapping.cbFrameSize == HDA_FRAME_SIZE_DEFAULT)
+                if (pStreamR3->State.Mapping.cbFrameSize == HDA_FRAME_SIZE_DEFAULT)
                 {
                     uint32_t cbDMARead = 0;
@@ -1119 +1120 @@
                      */
                     /** @todo Optimize channel data extraction! Use some SSE(3) / intrinsics? */
-                    for (unsigned m = 0; m < pStream->State.Mapping.cMappings; m++)
+                    for (unsigned m = 0; m < pStreamR3->State.Mapping.cMappings; m++)
                     {
-                        const uint32_t cbFrame  = pStream->State.Mapping.cbFrameSize;
+                        const uint32_t cbFrame  = pStreamR3->State.Mapping.cbFrameSize;
 
                         Assert(cbFree >= cbDMA);
 
-                        PPDMAUDIOSTREAMMAP pMap = &pStream->State.Mapping.paMappings[m];
+                        PPDMAUDIOSTREAMMAP pMap = &pStreamR3->State.Mapping.paMappings[m];
                         AssertPtr(pMap);
 
@@ -1150 +1151 @@
 
 #if 0 /* Too slow, even for release builds, so disabled it. */
-                                if (pStream->Dbg.Runtime.fEnabled)
-                                    DrvAudioHlpFileWrite(pStream->Dbg.Runtime.pFileDMAMapped, pvDstBuf, cbDstBuf,
+                                if (pStreamR3->Dbg.Runtime.fEnabled)
+                                    DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMAMapped, pvDstBuf, cbDstBuf,
                                                          0 /* fFlags */);
 #endif
@@ -1200 +1201 @@
             }
             else
-                LogRel(("HDA: Reading from stream #%RU8 DMA failed with %Rrc\n", pStream->u8SD, rc));
+                LogRel(("HDA: Reading from stream #%RU8 DMA failed with %Rrc\n", uSD, rc));
 
             STAM_PROFILE_STOP(&pThis->StatOut, a);
@@ -1217 +1218 @@
             /* Are we done doing the position adjustment?
              * Only then do the transfer accounting .*/
-            if (pStream->State.cfPosAdjustLeft == 0)
+            if (pStreamShared->State.cfPosAdjustLeft == 0)
             {
                 Assert(cbLeft >= cbDMA);
@@ -1230 +1231 @@
              * All guetsts rely on this, depending on the mechanism they use (LPIB register or DMA counters).
              */
-            uint32_t cbStreamPos = hdaR3StreamGetPosition(pThis, pStream);
-            if (cbStreamPos == pStream->u32CBL)
+            uint32_t cbStreamPos = hdaR3StreamGetPosition(pThis, pStreamShared);
+            if (cbStreamPos == pStreamShared->u32CBL)
                 cbStreamPos = 0;
 
-            hdaR3StreamSetPosition(pStream, cbStreamPos + cbDMA);
+            hdaR3StreamSetPosition(pStreamShared, pDevIns, pThis, cbStreamPos + cbDMA);
         }
 
         if (hdaR3BDLEIsComplete(pBDLE))
         {
-            Log3Func(("[SD%RU8] Complete: %R[bdle]\n", pStream->u8SD, pBDLE));
+            Log3Func(("[SD%RU8] Complete: %R[bdle]\n", uSD, pBDLE));
 
                 /* Does the current BDLE require an interrupt to be sent? */
@@ -1248 +1249 @@
                  *
                  * In such a case we need to skip such an interrupt and just move on. */
-                && pStream->State.cfPosAdjustLeft == 0)
+                && pStreamShared->State.cfPosAdjustLeft == 0)
             {
                 /* If the IOCE ("Interrupt On Completion Enable") bit of the SDCTL register is set
                  * we need to generate an interrupt.
                  */
-                if (HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_SDCTL_IOCE)
+                if (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_SDCTL_IOCE)
                 {
-                    pStream->State.cTransferPendingInterrupts++;
-
-                    AssertMsg(pStream->State.cTransferPendingInterrupts <= 32,
+                    pStreamShared->State.cTransferPendingInterrupts++;
+
+                    AssertMsg(pStreamShared->State.cTransferPendingInterrupts <= 32,
                               ("Too many pending interrupts (%RU8) for stream #%RU8\n",
-                               pStream->State.cTransferPendingInterrupts, pStream->u8SD));
+                               pStreamShared->State.cTransferPendingInterrupts, uSD));
                 }
             }
 
-            if (pStream->State.uCurBDLE == pStream->u16LVI)
-            {
-                pStream->State.uCurBDLE = 0;
+            if (pStreamShared->State.uCurBDLE == pStreamShared->u16LVI)
+            {
+                pStreamShared->State.uCurBDLE = 0;
             }
             else
-                pStream->State.uCurBDLE++;
+                pStreamShared->State.uCurBDLE++;
 
             /* Fetch the next BDLE entry. */
-            hdaR3BDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
+            hdaR3BDLEFetch(pDevIns, pBDLE, pStreamShared->u64BDLBase, pStreamShared->State.uCurBDLE);
         }
 
         /* Do the position adjustment accounting. */
-        pStream->State.cfPosAdjustLeft -=
-            RT_MIN(pStream->State.cfPosAdjustLeft, cbDMA / pStream->State.Mapping.cbFrameSize);
+        pStreamShared->State.cfPosAdjustLeft -=
+            RT_MIN(pStreamShared->State.cfPosAdjustLeft, cbDMA / pStreamR3->State.Mapping.cbFrameSize);
 
         if (RT_FAILURE(rc))
@@ -1283 +1284 @@
 
     Log3Func(("[SD%RU8] cbToProcess=%RU32, cbProcessed=%RU32, cbLeft=%RU32, %R[bdle], rc=%Rrc\n",
-              pStream->u8SD, cbToProcess, cbProcessed, cbLeft, pBDLE, rc));
+              uSD, cbToProcess, cbProcessed, cbLeft, pBDLE, rc));
 
     /* Sanity. */
@@ -1291 +1292 @@
     /* Only do the data accounting if we don't have to do any position
      * adjustment anymore. */
-    if (pStream->State.cfPosAdjustLeft == 0)
-    {
-        hdaR3StreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStream->State.Mapping.cbFrameSize,
+    if (pStreamShared->State.cfPosAdjustLeft == 0)
+    {
+        hdaR3StreamPeriodInc(pPeriod, RT_MIN(cbProcessed / pStreamR3->State.Mapping.cbFrameSize,
                                              hdaR3StreamPeriodGetRemainingFrames(pPeriod)));
 
-        pStream->State.cbTransferProcessed += cbProcessed;
+        pStreamShared->State.cbTransferProcessed += cbProcessed;
     }
 
     /* Make sure that we never report more stuff processed than initially announced. */
-    if (pStream->State.cbTransferProcessed > pStream->State.cbTransferSize)
-        pStream->State.cbTransferProcessed = pStream->State.cbTransferSize;
-
-    uint32_t cbTransferLeft     = pStream->State.cbTransferSize - pStream->State.cbTransferProcessed;
+    if (pStreamShared->State.cbTransferProcessed > pStreamShared->State.cbTransferSize)
+        pStreamShared->State.cbTransferProcessed = pStreamShared->State.cbTransferSize;
+
+    uint32_t cbTransferLeft     = pStreamShared->State.cbTransferSize - pStreamShared->State.cbTransferProcessed;
     bool     fTransferComplete  = !cbTransferLeft;
     uint64_t tsTransferNext     = 0;
@@ -1321 +1322 @@
          *         sound output. Running VLC on the guest will tell!
          */
-        const bool fWalClkSet = hdaR3WalClkSet(pThis,
+        const bool fWalClkSet = hdaR3WalClkSet(pThis, pThisCC,
                                                  hdaWalClkGetCurrent(pThis)
                                                + hdaR3StreamPeriodFramesToWalClk(pPeriod,
-                                                                                   pStream->State.cbTransferProcessed
-                                                                                 / pStream->State.Mapping.cbFrameSize),
+                                                                                   pStreamShared->State.cbTransferProcessed
+                                                                                 / pStreamR3->State.Mapping.cbFrameSize),
                                                false /* fForce */);
         RT_NOREF(fWalClkSet);
@@ -1331 +1332 @@
 
     /* Does the period have any interrupts outstanding? */
-    if (pStream->State.cTransferPendingInterrupts)
-    {
-        Log3Func(("[SD%RU8] Scheduling interrupt\n", pStream->u8SD));
+    if (pStreamShared->State.cTransferPendingInterrupts)
+    {
+        Log3Func(("[SD%RU8] Scheduling interrupt\n", uSD));
 
         /*
@@ -1346 +1347 @@
          * snd_hda_intel on Linux will tell.
          */
-        HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_SDSTS_BCIS;
+        HDA_STREAM_REG(pThis, STS, uSD) |= HDA_SDSTS_BCIS;
 
         /* Trigger an interrupt first and let hdaRegWriteSDSTS() deal with
          * ending / beginning a period. */
-        HDA_PROCESS_INTERRUPT(pThis->pDevInsR3, pThis);
+        HDA_PROCESS_INTERRUPT(pDevIns, pThis);
     }
     else /* Transfer still in-flight -- schedule the next timing slot. */
@@ -1359 +1360 @@
          * than we can transfer per timing slot? Clamp. */
         if (   !cbTransferNext
-            || cbTransferNext > pStream->State.cbTransferChunk)
-        {
-            cbTransferNext = pStream->State.cbTransferChunk;
+            || cbTransferNext > pStreamShared->State.cbTransferChunk)
+        {
+            cbTransferNext = pStreamShared->State.cbTransferChunk;
         }
 
-        tsTransferNext = tsNow + (cbTransferNext * pStream->State.cTicksPerByte);
+        tsTransferNext = tsNow + (cbTransferNext * pStreamShared->State.cTicksPerByte);
 
         /*
@@ -1374 +1375 @@
          */
         if (fTransferComplete)
-            pStream->State.cbTransferProcessed = 0;
+            pStreamShared->State.cbTransferProcessed = 0;
     }
 
@@ -1380 +1381 @@
     if (tsTransferNext) /* Can be 0 if no next transfer is needed. */
     {
-        Log3Func(("[SD%RU8] Scheduling timer\n", pStream->u8SD));
-
-        LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
-        Assert(!fInTimer || tsNow == PDMDevHlpTimerGet(pDevIns, pStream->hTimer));
-        hdaR3TimerSet(pDevIns, pStream, tsTransferNext, true /* fForce - skip tsTransferNext check */, fInTimer ? tsNow : 0);
-
-        pStream->State.tsTransferNext = tsTransferNext;
-    }
-
-    pStream->State.tsTransferLast = tsNow;
+        Log3Func(("[SD%RU8] Scheduling timer\n", uSD));
+
+        LogFunc(("Timer set SD%RU8\n", uSD));
+        Assert(!fInTimer || tsNow == PDMDevHlpTimerGet(pDevIns, pStreamShared->hTimer));
+        hdaR3TimerSet(pDevIns, pStreamShared, tsTransferNext,
+                      true /* fForce - skip tsTransferNext check */, fInTimer ? tsNow : 0);
+
+        pStreamShared->State.tsTransferNext = tsTransferNext;
+    }
+
+    pStreamShared->State.tsTransferLast = tsNow;
 
     Log3Func(("[SD%RU8] cbTransferLeft=%RU32 -- %RU32/%RU32\n",
-              pStream->u8SD, cbTransferLeft, pStream->State.cbTransferProcessed, pStream->State.cbTransferSize));
+              uSD, cbTransferLeft, pStreamShared->State.cbTransferProcessed, pStreamShared->State.cbTransferSize));
     Log3Func(("[SD%RU8] fTransferComplete=%RTbool, cTransferPendingInterrupts=%RU8\n",
-              pStream->u8SD, fTransferComplete, pStream->State.cTransferPendingInterrupts));
+              uSD, fTransferComplete, pStreamShared->State.cTransferPendingInterrupts));
     Log3Func(("[SD%RU8] tsNow=%RU64, tsTransferNext=%RU64 (in %RU64 ticks)\n",
-              pStream->u8SD, tsNow, tsTransferNext, tsTransferNext - tsNow));
+              uSD, tsNow, tsTransferNext, tsTransferNext - tsNow));
 
     hdaR3StreamPeriodUnlock(pPeriod);
-    hdaR3StreamUnlock(pStream);
+    hdaR3StreamUnlock(pStreamR3);
 
     return VINF_SUCCESS;
@@ -1421 +1423 @@
  * (with fInTimer set to @c false).
  *
- * @param   pDevIns     The device instance.
- * @param   pStream     HDA stream to update.
- * @param   fInTimer    Whether to this function was called from the timer
- *                      context or an asynchronous I/O stream thread (if supported).
- */
-void hdaR3StreamUpdate(PPDMDEVINS pDevIns, PHDASTREAM pStream, bool fInTimer)
-{
-    if (!pStream)
+ * @param   pDevIns         The device instance.
+ * @param   pThis           The shared HDA device state.
+ * @param   pThisCC         The ring-3 HDA device state.
+ * @param   pStreamShared   HDA stream to update (shared bits).
+ * @param   pStreamR3       HDA stream to update (ring-3 bits).
+ * @param   fInTimer        Whether to this function was called from the timer
+ *                          context or an asynchronous I/O stream thread (if supported).
+ */
+void hdaR3StreamUpdate(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC,
+                       PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, bool fInTimer)
+{
+    if (!pStreamShared)
         return;
 
     PAUDMIXSINK pSink = NULL;
-    if (   pStream->pMixSink
-        && pStream->pMixSink->pMixSink)
-    {
-        pSink = pStream->pMixSink->pMixSink;
-    }
+    if (pStreamR3->pMixSink)
+        pSink = pStreamR3->pMixSink->pMixSink;
 
     if (!AudioMixerSinkIsActive(pSink)) /* No sink available? Bail out. */
@@ -1443 +1446 @@
     int rc2;
 
-    if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_OUT) /* Output (SDO). */
+    if (hdaGetDirFromSD(pStreamShared->u8SD) == PDMAUDIODIR_OUT) /* Output (SDO). */
     {
         bool fDoRead = false; /* Whether to read from the HDA stream or not. */
@@ -1451 +1454 @@
 # endif
         {
-            const uint32_t cbStreamFree = hdaR3StreamGetFree(pStream);
+            const uint32_t cbStreamFree = hdaR3StreamGetFree(pStreamR3);
             if (cbStreamFree)
             {
                 /* Do the DMA transfer. */
-                rc2 = hdaR3StreamTransfer(pDevIns, pStream, cbStreamFree, fInTimer);
+                rc2 = hdaR3StreamTransfer(pDevIns, pThis, pThisCC, pStreamShared, pStreamR3, cbStreamFree, fInTimer);
                 AssertRC(rc2);
             }
@@ -1461 +1464 @@
             /* Only read from the HDA stream at the given scheduling rate. */
             const uint64_t tsNowNs = RTTimeNanoTS();
-            if (tsNowNs - pStream->State.tsLastUpdateNs >= pStream->State.Cfg.Device.cMsSchedulingHint * RT_NS_1MS)
+            if (tsNowNs - pStreamShared->State.tsLastUpdateNs >= pStreamShared->State.Cfg.Device.cMsSchedulingHint * RT_NS_1MS)
             {
                 fDoRead = true;
-                pStream->State.tsLastUpdateNs = tsNowNs;
+                pStreamShared->State.tsLastUpdateNs = tsNowNs;
             }
         }
 
-        Log3Func(("[SD%RU8] fInTimer=%RTbool, fDoRead=%RTbool\n", pStream->u8SD, fInTimer, fDoRead));
+        Log3Func(("[SD%RU8] fInTimer=%RTbool, fDoRead=%RTbool\n", pStreamShared->u8SD, fInTimer, fDoRead));
 
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
         if (fDoRead)
         {
-            rc2 = hdaR3StreamAsyncIONotify(pStream);
+            rc2 = hdaR3StreamAsyncIONotify(pStreamR3);
             AssertRC(rc2);
         }
@@ -1486 +1489 @@
 # endif
             const uint32_t cbSinkWritable     = AudioMixerSinkGetWritable(pSink);
-            const uint32_t cbStreamReadable   = hdaR3StreamGetUsed(pStream);
+            const uint32_t cbStreamReadable   = hdaR3StreamGetUsed(pStreamR3);
             const uint32_t cbToReadFromStream = RT_MIN(cbStreamReadable, cbSinkWritable);
 
-            Log3Func(("[SD%RU8] cbSinkWritable=%RU32, cbStreamReadable=%RU32\n", pStream->u8SD, cbSinkWritable, cbStreamReadable));
+            Log3Func(("[SD%RU8] cbSinkWritable=%RU32, cbStreamReadable=%RU32\n", pStreamShared->u8SD, cbSinkWritable, cbStreamReadable));
 
             if (cbToReadFromStream)
             {
                 /* Read (guest output) data and write it to the stream's sink. */
-                rc2 = hdaR3StreamRead(pStream, cbToReadFromStream, NULL /* pcbRead */);
+                rc2 = hdaR3StreamRead(pStreamR3, cbToReadFromStream, NULL /* pcbRead */);
                 AssertRC(rc2);
             }
@@ -1517 +1520 @@
 
             /* How much (guest input) data is available for writing at the moment for the HDA stream? */
-            const uint32_t cbStreamFree = hdaR3StreamGetFree(pStream);
-
-            Log3Func(("[SD%RU8] cbSinkReadable=%RU32, cbStreamFree=%RU32\n", pStream->u8SD, cbSinkReadable, cbStreamFree));
+            const uint32_t cbStreamFree = hdaR3StreamGetFree(pStreamR3);
+
+            Log3Func(("[SD%RU8] cbSinkReadable=%RU32, cbStreamFree=%RU32\n", pStreamShared->u8SD, cbSinkReadable, cbStreamFree));
 
             /* Do not read more than the HDA stream can hold at the moment.
@@ -1544 +1547 @@
                     /* Write (guest input) data to the stream which was read from stream's sink before. */
                     uint32_t cbWritten;
-                    rc2 = hdaR3StreamWrite(pStream, abFIFO, cbRead, &cbWritten);
+                    rc2 = hdaR3StreamWrite(pStreamR3, abFIFO, cbRead, &cbWritten);
                     AssertRCBreak(rc2);
-
-                    if (!cbWritten)
-                    {
-                        AssertFailed(); /* Should never happen, as we know how much we can write. */
-                        break;
-                    }
+                    AssertBreak(cbWritten > 0); /* Should never happen, as we know how much we can write. */
 
                     Assert(cbSinkReadable >= cbRead);
@@ -1565 +1563 @@
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
             const uint64_t tsNowNs = RTTimeNanoTS();
-            if (tsNowNs - pStream->State.tsLastUpdateNs >= pStream->State.Cfg.Device.cMsSchedulingHint * RT_NS_1MS)
-            {
-                rc2 = hdaR3StreamAsyncIONotify(pStream);
+            if (tsNowNs - pStreamShared->State.tsLastUpdateNs >= pStreamShared->State.Cfg.Device.cMsSchedulingHint * RT_NS_1MS)
+            {
+                rc2 = hdaR3StreamAsyncIONotify(pStreamR3);
                 AssertRC(rc2);
 
-                pStream->State.tsLastUpdateNs = tsNowNs;
+                pStreamShared->State.tsLastUpdateNs = tsNowNs;
             }
 # endif
-            const uint32_t cbStreamUsed = hdaR3StreamGetUsed(pStream);
+            const uint32_t cbStreamUsed = hdaR3StreamGetUsed(pStreamR3);
             if (cbStreamUsed)
             {
-                rc2 = hdaR3StreamTransfer(pDevIns, pStream, cbStreamUsed, fInTimer);
+                rc2 = hdaR3StreamTransfer(pDevIns, pThis, pThisCC, pStreamShared, pStreamR3, cbStreamUsed, fInTimer);
                 AssertRC(rc2);
             }
@@ -1589 +1587 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to lock.
- */
-void hdaR3StreamLock(PHDASTREAM pStream)
-{
-    AssertPtrReturnVoid(pStream);
+ * @param   pStreamR3           HDA stream to lock (ring-3 bits).
+ */
+void hdaR3StreamLock(PHDASTREAMR3 pStreamR3)
+{
+    AssertPtrReturnVoid(pStreamR3);
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    int rc2 = RTCritSectEnter(&pStream->CritSect);
+    int rc2 = RTCritSectEnter(&pStreamR3->CritSect);
     AssertRC(rc2);
 # else
@@ -1606 +1604 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to unlock.
- */
-void hdaR3StreamUnlock(PHDASTREAM pStream)
-{
-    AssertPtrReturnVoid(pStream);
+ * @param   pStreamR3           HDA stream to unlock (ring-3 bits).
+ */
+void hdaR3StreamUnlock(PHDASTREAMR3 pStreamR3)
+{
+    AssertPtrReturnVoid(pStreamR3);
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    int rc2 = RTCritSectLeave(&pStream->CritSect);
+    int rc2 = RTCritSectLeave(&pStreamR3->CritSect);
     AssertRC(rc2);
 # endif
 }
 
+#if 0 /* unused - no prototype even */
 /**
  * Updates an HDA stream's current read or write buffer position (depending on the stream type) by
@@ -1622 +1621 @@
  *
  * @returns Set LPIB value.
+ * @param   pDevIns             The device instance.
  * @param   pStream             HDA stream to update read / write position for.
  * @param   u32LPIB             New LPIB (position) value to set.
  */
-uint32_t hdaR3StreamUpdateLPIB(PHDASTREAM pStream, uint32_t u32LPIB)
-{
-    AssertPtrReturn(pStream, 0);
-
-    AssertMsg(u32LPIB <= pStream->u32CBL,
-              ("[SD%RU8] New LPIB (%RU32) exceeds CBL (%RU32)\n", pStream->u8SD, u32LPIB, pStream->u32CBL));
-
-    const PHDASTATE pThis = pStream->pHDAState;
-
-    u32LPIB = RT_MIN(u32LPIB, pStream->u32CBL);
+uint32_t hdaR3StreamUpdateLPIB(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared, uint32_t u32LPIB)
+{
+    AssertMsg(u32LPIB <= pStreamShared->u32CBL,
+              ("[SD%RU8] New LPIB (%RU32) exceeds CBL (%RU32)\n", pStreamShared->u8SD, u32LPIB, pStreamShared->u32CBL));
+
+    u32LPIB = RT_MIN(u32LPIB, pStreamShared->u32CBL);
 
     LogFlowFunc(("[SD%RU8] LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",
-                 pStream->u8SD, u32LPIB, pThis->fDMAPosition));
+                 pStreamShared->u8SD, u32LPIB, pThis->fDMAPosition));
 
     /* Update LPIB in any case. */
-    HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) = u32LPIB;
+    HDA_STREAM_REG(pThis, LPIB, pStreamShared->u8SD) = u32LPIB;
 
     /* Do we need to tell the current DMA position? */
     if (pThis->fDMAPosition)
     {
-        int rc2 = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
-                                        pThis->u64DPBase + (pStream->u8SD * 2 * sizeof(uint32_t)),
+        int rc2 = PDMDevHlpPCIPhysWrite(pDevIns,
+                                        pThis->u64DPBase + (pStreamShared->u8SD * 2 * sizeof(uint32_t)),
                                         (void *)&u32LPIB, sizeof(uint32_t));
         AssertRC(rc2);
@@ -1653 +1649 @@
     return u32LPIB;
 }
+#endif
 
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
@@ -1664 +1661 @@
 {
     /* At least LVI and the BDL base must be set. */
-    if (   !pStream->u16LVI
-        || !pStream->u64BDLBase)
+    if (   !pStreamShared->u16LVI
+        || !pStreamShared->u64BDLBase)
     {
         return false;
@@ -1688 +1685 @@
     size_t cRanges = 0;
 
-    for (uint16_t i = 0; i < pStream->u16LVI + 1; i++)
+    for (uint16_t i = 0; i < pStreamShared->u16LVI + 1; i++)
     {
         HDABDLE BDLE;
-        rc = hdaR3BDLEFetch(pThis, &BDLE, pStream->u64BDLBase, i /* Index */);
+        rc = hdaR3BDLEFetch(pDevIns, &BDLE, pStreamShared->u64BDLBase, i /* Index */);
         if (RT_FAILURE(rc))
             break;
@@ -1827 +1824 @@
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
 /**
+ * @callback_method_impl{FNRTTHREAD,
  * Asynchronous I/O thread for a HDA stream.
- * This will do the heavy lifting work for us as soon as it's getting notified by another thread.
- *
- * @returns IPRT status code.
- * @param   hThreadSelf         Thread handle.
- * @param   pvUser              User argument. Must be of type PHDASTREAMTHREADCTX.
- */
-DECLCALLBACK(int) hdaR3StreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser)
-{
-    PHDASTREAMTHREADCTX pCtx = (PHDASTREAMTHREADCTX)pvUser;
-    AssertPtr(pCtx);
-    PHDASTREAM pStream = pCtx->pStream;
-
-    AssertPtr(pStream);
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
-
-    PPDMDEVINS pDevIns = pCtx->pThis->pDevInsR3;
-
+ *
+ * This will do the heavy lifting work for us as soon as it's getting notified
+ * by another thread.}
+ */
+static DECLCALLBACK(int) hdaR3StreamAsyncIOThread(RTTHREAD hThreadSelf, void *pvUser)
+{
+    PHDASTREAMR3 const       pStreamR3     = (PHDASTREAMR3)pvUser;
+    PHDASTREAMSTATEAIO const pAIO          = &pStreamR3->State.AIO;
+    PHDASTATE const          pThis         = pStreamR3->pHDAStateShared;
+    PHDASTATER3 const        pThisCC       = pStreamR3->pHDAStateR3;
+    PPDMDEVINS const         pDevIns       = pThisCC->pDevIns;
+    PHDASTREAM const         pStreamShared = &pThis->aStreams[pStreamR3 - &pThisCC->aStreams[0]];
+    Assert(pStreamR3 - &pThisCC->aStreams[0] == pStreamR3->u8SD);
+    Assert(pStreamShared->u8SD == pStreamR3->u8SD);
+
+    /* Signal parent thread that we've started  */
     ASMAtomicXchgBool(&pAIO->fStarted, true);
-
     RTThreadUserSignal(hThreadSelf);
 
-    LogFunc(("[SD%RU8] Started\n", pStream->u8SD));
+    LogFunc(("[SD%RU8] Started\n", pStreamShared->u8SD));
 
     for (;;)
     {
-        int rc2 = RTSemEventWait(pAIO->Event, RT_INDEFINITE_WAIT);
+        int rc2 = RTSemEventWait(pAIO->hEvent, RT_INDEFINITE_WAIT);
         if (RT_FAILURE(rc2))
             break;
@@ -1861 +1857 @@
 
         rc2 = RTCritSectEnter(&pAIO->CritSect);
+        AssertRC(rc2);
         if (RT_SUCCESS(rc2))
         {
@@ -1869 +1866 @@
             }
 
-            hdaR3StreamUpdate(pDevIns, pStream, false /* fInTimer */);
+            hdaR3StreamUpdate(pDevIns, pThis, pThisCC, pStreamShared, pStreamR3, false /* fInTimer */);
 
             int rc3 = RTCritSectLeave(&pAIO->CritSect);
             AssertRC(rc3);
         }
-
-        AssertRC(rc2);
-    }
-
-    LogFunc(("[SD%RU8] Ended\n", pStream->u8SD));
-
+    }
+
+    LogFunc(("[SD%RU8] Ended\n", pStreamShared->u8SD));
     ASMAtomicXchgBool(&pAIO->fStarted, false);
 
@@ -1889 +1883 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA audio stream to create the async I/O thread for.
- */
-int hdaR3StreamAsyncIOCreate(PHDASTREAM pStream)
-{
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+ * @param   pStreamR3           HDA audio stream to create the async I/O thread for.
+ */
+int hdaR3StreamAsyncIOCreate(PHDASTREAMR3 pStreamR3)
+{
+    PHDASTREAMSTATEAIO pAIO = &pStreamR3->State.AIO;
 
     int rc;
@@ -1902 +1896 @@
         pAIO->fEnabled  = true; /* Enabled by default. */
 
-        rc = RTSemEventCreate(&pAIO->Event);
+        rc = RTSemEventCreate(&pAIO->hEvent);
         if (RT_SUCCESS(rc))
         {
@@ -1908 +1902 @@
             if (RT_SUCCESS(rc))
             {
-                HDASTREAMTHREADCTX Ctx = { pStream->pHDAState, pStream };
-
-                char szThreadName[64];
-                RTStrPrintf2(szThreadName, sizeof(szThreadName), "hdaAIO%RU8", pStream->u8SD);
-
-                rc = RTThreadCreate(&pAIO->Thread, hdaR3StreamAsyncIOThread, &Ctx,
-                                    0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, szThreadName);
+                rc = RTThreadCreateF(&pAIO->hThread, hdaR3StreamAsyncIOThread, pStreamR3, 0 /*cbStack*/,
+                                     RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "hdaAIO%RU8", pStreamR3->u8SD);
                 if (RT_SUCCESS(rc))
-                    rc = RTThreadUserWait(pAIO->Thread, 10 * 1000 /* 10s timeout */);
+                    rc = RTThreadUserWait(pAIO->hThread, 10 * 1000 /* 10s timeout */);
             }
         }
@@ -1923 +1912 @@
         rc = VINF_SUCCESS;
 
-    LogFunc(("[SD%RU8] Returning %Rrc\n", pStream->u8SD, rc));
+    LogFunc(("[SD%RU8] Returning %Rrc\n", pStreamR3->u8SD, rc));
     return rc;
 }
@@ -1931 +1920 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA audio stream to destroy the async I/O thread for.
- */
-int hdaR3StreamAsyncIODestroy(PHDASTREAM pStream)
-{
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+ * @param   pStreamR3           HDA audio stream to destroy the async I/O thread for.
+ */
+static int hdaR3StreamAsyncIODestroy(PHDASTREAMR3 pStreamR3)
+{
+    PHDASTREAMSTATEAIO pAIO = &pStreamR3->State.AIO;
 
     if (!ASMAtomicReadBool(&pAIO->fStarted))
@@ -1942 +1931 @@
     ASMAtomicWriteBool(&pAIO->fShutdown, true);
 
-    int rc = hdaR3StreamAsyncIONotify(pStream);
+    int rc = hdaR3StreamAsyncIONotify(pStreamR3);
     AssertRC(rc);
 
     int rcThread;
-    rc = RTThreadWait(pAIO->Thread, 30 * 1000 /* 30s timeout */, &rcThread);
+    rc = RTThreadWait(pAIO->hThread, 30 * 1000 /* 30s timeout */, &rcThread);
     LogFunc(("Async I/O thread ended with %Rrc (%Rrc)\n", rc, rcThread));
 
     if (RT_SUCCESS(rc))
     {
+        pAIO->hThread = NIL_RTTHREAD;
+
         rc = RTCritSectDelete(&pAIO->CritSect);
         AssertRC(rc);
 
-        rc = RTSemEventDestroy(pAIO->Event);
+        rc = RTSemEventDestroy(pAIO->hEvent);
         AssertRC(rc);
+        pAIO->hEvent = NIL_RTSEMEVENT;
 
         pAIO->fStarted  = false;
@@ -1962 +1954 @@
     }
 
-    LogFunc(("[SD%RU8] Returning %Rrc\n", pStream->u8SD, rc));
+    LogFunc(("[SD%RU8] Returning %Rrc\n", pStreamR3->u8SD, rc));
     return rc;
 }
@@ -1970 +1962 @@
  *
  * @returns IPRT status code.
- * @param   pStream             HDA stream to notify async I/O thread for.
- */
-int hdaR3StreamAsyncIONotify(PHDASTREAM pStream)
-{
-    return RTSemEventSignal(pStream->State.AIO.Event);
+ * @param   pStreamR3           HDA stream to notify async I/O thread for.
+ */
+static int hdaR3StreamAsyncIONotify(PHDASTREAMR3 pStreamR3)
+{
+    return RTSemEventSignal(pStreamR3->State.AIO.hEvent);
 }
 
@@ -1980 +1972 @@
  * Locks the async I/O thread of a specific HDA audio stream.
  *
- * @param   pStream             HDA stream to lock async I/O thread for.
- */
-void hdaR3StreamAsyncIOLock(PHDASTREAM pStream)
-{
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+ * @param   pStreamR3           HDA stream to lock async I/O thread for.
+ */
+void hdaR3StreamAsyncIOLock(PHDASTREAMR3 pStreamR3)
+{
+    PHDASTREAMSTATEAIO pAIO = &pStreamR3->State.AIO;
 
     if (!ASMAtomicReadBool(&pAIO->fStarted))
@@ -1996 +1988 @@
  * Unlocks the async I/O thread of a specific HDA audio stream.
  *
- * @param   pStream             HDA stream to unlock async I/O thread for.
- */
-void hdaR3StreamAsyncIOUnlock(PHDASTREAM pStream)
-{
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+ * @param   pStreamR3           HDA stream to unlock async I/O thread for.
+ */
+void hdaR3StreamAsyncIOUnlock(PHDASTREAMR3 pStreamR3)
+{
+    PHDASTREAMSTATEAIO pAIO = &pStreamR3->State.AIO;
 
     if (!ASMAtomicReadBool(&pAIO->fStarted))
@@ -2012 +2004 @@
  * Enables (resumes) or disables (pauses) the async I/O thread.
  *
- * @param   pStream             HDA stream to enable/disable async I/O thread for.
+ * @param   pStreamR3           HDA stream to enable/disable async I/O thread for.
  * @param   fEnable             Whether to enable or disable the I/O thread.
  *
  * @remarks Does not do locking.
  */
-void hdaR3StreamAsyncIOEnable(PHDASTREAM pStream, bool fEnable)
-{
-    PHDASTREAMSTATEAIO pAIO = &pStream->State.AIO;
+void hdaR3StreamAsyncIOEnable(PHDASTREAMR3 pStreamR3, bool fEnable)
+{
+    PHDASTREAMSTATEAIO pAIO = &pStreamR3->State.AIO;
     ASMAtomicXchgBool(&pAIO->fEnabled, fEnable);
 }

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

@@ -34 +34 @@
 {
     /** Thread handle for the actual I/O thread. */
-    RTTHREAD                Thread;
+    RTTHREAD                hThread;
     /** Event for letting the thread know there is some data to process. */
-    RTSEMEVENT              Event;
+    RTSEMEVENT              hEvent;
     /** Critical section for synchronizing access. */
     RTCRITSECT              CritSect;
@@ -123 +123 @@
     volatile bool           fRunning;
     /** Unused, padding. */
-    uint8_t                 Padding0[4];
-#ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-    /** Asynchronous I/O state members. */
-    HDASTREAMSTATEAIO       AIO;
-#endif
-    /** This stream's data mapping. */
-    HDASTREAMMAP            Mapping;
+    uint8_t                 abPadding0[4];
     /** Current BDLE (Buffer Descriptor List Entry). */
     HDABDLE                 BDLE;
-    /** Circular buffer (FIFO) for holding DMA'ed data. */
-    R3PTRTYPE(PRTCIRCBUF)   pCircBuf;
-#if HC_ARCH_BITS == 32
-    RTR3PTR                 Padding1;
-#endif
     /** Timestamp of the last DMA data transfer. */
     uint64_t                tsTransferLast;
@@ -153 +142 @@
      *  BDLE interrupt-on-completion (IOC) bits set. */
     uint8_t                 cTransferPendingInterrupts;
-    uint8_t                 Padding2[2];
+    uint8_t                 abPadding2[3];
     /** The stream's timer Hz rate.
      *  This value can can be different from the device's default Hz rate,
@@ -167 +156 @@
      *  0 if position adjustment handling is done or inactive. */
     uint16_t                cfPosAdjustLeft;
+    uint16_t                u16Padding3;
     /** (Virtual) clock ticks per byte. */
     uint64_t                cTicksPerByte;
@@ -177 +167 @@
     PDMAUDIOSTREAMCFG       Cfg;
     uint32_t                Padding4;
-#ifdef HDA_USE_DMA_ACCESS_HANDLER
-    /** List of DMA handlers. */
-    RTLISTANCHORR3          lstDMAHandlers;
-#endif
-   /** Timestamp (in ns) of last stream update. */
+    /** Timestamp (in ns) of last stream update. */
     uint64_t                tsLastUpdateNs;
 } HDASTREAMSTATE;
 AssertCompileSizeAlignment(HDASTREAMSTATE, 8);
-/** Pointer to the internal state of an HDA stream. */
-typedef HDASTREAMSTATE *PHDASTREAMSTATE;
-
-/**
- * An HDA stream (SDI / SDO).
+
+/**
+ * An HDA stream (SDI / SDO) - shared.
  *
  * @note This HDA stream has nothing to do with a regular audio stream handled
@@ -232 +216 @@
     uint16_t                    u16LVI;
     uint16_t                    au16Padding1[2];
-    /** Pointer to the HDA state this stream is attached to. */
-    R3PTRTYPE(PHDASTATE)        pHDAState;
+    /** The timer for pumping data thru the attached LUN drivers. */
+    TMTIMERHANDLE               hTimer;
+    /** Internal state of this stream. */
+    HDASTREAMSTATE              State;
+} HDASTREAM;
+/** Pointer to an HDA stream (SDI / SDO).  */
+typedef HDASTREAM *PHDASTREAM;
+
+
+/**
+ * An HDA stream (SDI / SDO) - ring-3 bits.
+ */
+typedef struct HDASTREAMR3
+{
+    /** Stream descriptor number (SDn). */
+    uint8_t                     u8SD;
+    uint8_t                     abPadding[7];
+    /** The shared state for the parent HDA device. */
+    R3PTRTYPE(PHDASTATE)        pHDAStateShared;
+    /** The ring-3 state for the parent HDA device. */
+    R3PTRTYPE(PHDASTATER3)      pHDAStateR3;
     /** Pointer to HDA sink this stream is attached to. */
     R3PTRTYPE(PHDAMIXERSINK)    pMixSink;
-    /** The timer for pumping data thru the attached LUN drivers. */
-    TMTIMERHANDLE               hTimer;
 #ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
     /** The stream's critical section to serialize access between the async I/O
@@ -244 +245 @@
 #endif
     /** Internal state of this stream. */
-    HDASTREAMSTATE              State;
-    /** Debug information. */
+    struct
+    {
+        /** This stream's data mapping. */
+        HDASTREAMMAP            Mapping;
+        /** Circular buffer (FIFO) for holding DMA'ed data. */
+        R3PTRTYPE(PRTCIRCBUF)   pCircBuf;
+#ifdef HDA_USE_DMA_ACCESS_HANDLER
+        /** List of DMA handlers. */
+        RTLISTANCHORR3          lstDMAHandlers;
+#endif
+#ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
+        /** Asynchronous I/O state members. */
+        HDASTREAMSTATEAIO       AIO;
+#endif
+    } State;
+    /** Debug bits. */
     HDASTREAMDEBUG              Dbg;
-} HDASTREAM;
+} HDASTREAMR3;
 /** Pointer to an HDA stream (SDI / SDO).  */
-typedef HDASTREAM *PHDASTREAM;
-
-#ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-/**
- * HDA stream thread context (arguments).
- */
-typedef struct HDASTREAMTHREADCTX
-{
-    PHDASTATE  pThis;
-    PHDASTREAM pStream;
-} HDASTREAMTHREADCTX, *PHDASTREAMTHREADCTX;
-#endif
+typedef HDASTREAMR3 *PHDASTREAMR3;
 
 #ifdef IN_RING3
@@ -267 +271 @@
  * @{
  */
-int               hdaR3StreamCreate(PHDASTREAM pStream, PHDASTATE pThis, uint8_t u8SD);
-void              hdaR3StreamDestroy(PHDASTREAM pStream);
-int               hdaR3StreamInit(PPDMDEVINS pDevIns, 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 tsNow);
-uint64_t          hdaR3StreamTransferGetNext(PHDASTREAM pStream);
-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(PPDMDEVINS pDevIns, PHDASTREAM pStream, bool fAsync);
+int                 hdaR3StreamConstruct(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, PHDASTATE pThis,
+                                         PHDASTATER3 pThisCC, uint8_t uSD);
+void                hdaR3StreamDestroy(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3);
+int                 hdaR3StreamSetUp(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTREAM pStreamShared,
+                                     PHDASTREAMR3 pStreamR3, uint8_t uSD);
+void                hdaR3StreamReset(PHDASTATE pThis, PHDASTATER3 pThisCC,
+                                     PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, uint8_t uSD);
+int                 hdaR3StreamEnable(PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, bool fEnable);
+/* uint32_t            hdaR3StreamGetPosition(PHDASTATE pThis, PHDASTREAMR3 pStreamShared); - only used in HDAStream.cpp */
+/*void                hdaR3StreamSetPosition(PHDASTREAM pStream, PPDMDEVINS pDevIns, PHDASTATE pThis, uint32_t u32LPIB); - only used in HDAStream.cpp */
+/*uint32_t            hdaR3StreamGetFree(PHDASTREAM pStream); - only used in HDAStream.cpp */
+/*uint32_t            hdaR3StreamGetUsed(PHDASTREAM pStream); - only used in HDAStream.cpp */
+bool                hdaR3StreamTransferIsScheduled(PHDASTREAM pStreamShared, uint64_t tsNow);
+uint64_t            hdaR3StreamTransferGetNext(PHDASTREAM pStreamShared);
+void                hdaR3StreamLock(PHDASTREAMR3 pStreamR3);
+void                hdaR3StreamUnlock(PHDASTREAMR3 pStreamR3);
+/* int                 hdaR3StreamRead(PHDASTREAM pStream, uint32_t cbToRead, uint32_t *pcbRead); - only used in HDAStream.cpp */
+/*int                 hdaR3StreamWrite(PHDASTREAM pStream, const void *pvBuf, uint32_t cbBuf, uint32_t *pcbWritten); - only used in HDAStream.cpp */
+void                hdaR3StreamUpdate(PPDMDEVINS pDevIns, PHDASTATE pThis, PHDASTATER3 pThisCC,
+                                      PHDASTREAM pStreamShared, PHDASTREAMR3 pStreamR3, bool fInTimer);
+PHDASTREAM          hdaR3StreamR3ToShared(PHDASTREAMR3 pStreamCC);
 # ifdef HDA_USE_DMA_ACCESS_HANDLER
-bool              hdaR3StreamRegisterDMAHandlers(PHDASTREAM pStream);
-void              hdaR3StreamUnregisterDMAHandlers(PHDASTREAM pStream);
+bool                hdaR3StreamRegisterDMAHandlers(PHDASTREAM pStream);
+void                hdaR3StreamUnregisterDMAHandlers(PHDASTREAM pStream);
 # endif
 /** @} */
@@ -293 +302 @@
  */
 # ifdef VBOX_WITH_AUDIO_HDA_ASYNC_IO
-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);
+int                 hdaR3StreamAsyncIOCreate(PHDASTREAMR3 pStreamR3);
+void                hdaR3StreamAsyncIOLock(PHDASTREAMR3 pStreamR3);
+void                hdaR3StreamAsyncIOUnlock(PHDASTREAMR3 pStreamR3);
+void                hdaR3StreamAsyncIOEnable(PHDASTREAMR3 pStreamR3, bool fEnable);
 # endif /* VBOX_WITH_AUDIO_HDA_ASYNC_IO */
 /** @} */