Changeset 64572 in vbox for trunk/src/VBox

Timestamp:

Nov 4, 2016 12:54:38 PM (8 years ago)

Author:

vboxsync

Message:

Audio/HDA: Rewritten large parts of the interrupt delivery and DMA handling to improve audio data delivery.

We now update the interrupt status when needed, and not when the status is read by the guest -- this created all kinds of funny side effects. Also, split out the DMA transfers to an own routine for easier debugging and made sure we transfer the correct sizes according to FIFOS boundaries.

Location:

trunk/src/VBox/Devices

Files:

• Audio/DevHDA.cpp (modified) (83 diffs)
• testcase/tstDeviceStructSizeRC.cpp (modified) (2 diffs)

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

@@ -179 +179 @@
 #define HDA_REG_STATESTS            7 /* 0x0E */
 #define HDA_RMX_STATESTS            7
-#define HDA_STATES_SCSF             0x7
+#define HDA_STATESTS_SCSF_MASK      0x7 /* State Change Status Flags (6.2.8). */
 
 #define HDA_REG_GSTS                8 /* 0x10-0x11*/
@@ -477 +477 @@
  * Other values not listed are not supported.
  */
+/** Maximum FIFO size (in bytes). */
+#define HDA_FIFO_MAX                256
+
 #define HDA_SDIFIFO_120B            0x77 /* 8-, 16-, 20-, 24-, 32-bit Input Streams */
 #define HDA_SDIFIFO_160B            0x9F /* 20-, 24-bit Input Streams Streams */
@@ -566 +569 @@
      *  Used to check if we need fill up the FIFO again. */
     uint32_t     cbBelowFIFOW;
-    /** The buffer descriptor's internal DMA buffer. */
-    uint8_t      au8FIFO[HDA_SDOFIFO_256B + 1];
     /** Current offset in DMA buffer (in bytes).*/
     uint32_t     u32BufOff;
@@ -603 +604 @@
     /** Number of audio channels in this stream. */
     uint8_t                           cChannels;
-    /** Array audio channels. */
+    /** Array of audio channels. */
     R3PTRTYPE(PPDMAUDIOSTREAMCHANNEL) paChannels;
+    /** Circular buffer holding for holding audio data for this mapping. */
     R3PTRTYPE(PRTCIRCBUF)             pCircBuf;
 } HDASTREAMMAPPING, *PHDASTREAMMAPPING;
@@ -616 +618 @@
      *  maximum (cBDLE) is reached. */
     uint16_t                uCurBDLE;
-    /** Stop indicator. */
-    volatile bool           fDoStop;
-    /** Flag indicating whether this stream is in an
-     *  active (operative) state or not. */
-    volatile bool           fActive;
     /** Flag indicating whether this stream currently is
      *  in reset mode and therefore not acccessible by the guest. */
     volatile bool           fInReset;
     /** Unused, padding. */
-    bool                    fPadding;
+    uint32_t                Padding0;
     /** Critical section to serialize access. */
     RTCRITSECT              CritSect;
-    /** Event signalling that the stream's state has been changed. */
-    RTSEMEVENT              hStateChangedEvent;
     /** This stream's data mapping. */
     HDASTREAMMAPPING        Mapping;
     /** Current BDLE (Buffer Descriptor List Entry). */
     HDABDLE                 BDLE;
+    /** Circular buffer (FIFO) for holding DMA'ed data. */
+    R3PTRTYPE(PRTCIRCBUF)   pCircBuf;
 } HDASTREAMSTATE, *PHDASTREAMSTATE;
 
@@ -659 +656 @@
 
 /**
- * Structure for keeping a HDA stream state.
+ * Structure for keeping a HDA stream (SDI / SDO).
+ *
+ * Note: This HDA stream has nothing to do with a regular audio stream handled
+ * by the audio connector or the audio mixer. This HDA stream is a serial data in/out
+ * stream (SDI/SDO) defined in hardware and can contain multiple audio streams
+ * in one single SDI/SDO (interleaving streams).
+ *
+ * How a specific SDI/SDO is mapped to our internal audio streams relies on the
+ * stream channel mappings.
  *
  * Contains only register values which do *not* change until a
@@ -678 +683 @@
     /** FIFO Size (FIFOS).
      *  Maximum number of bytes that may have been DMA'd into
-     *  memory but not yet transmitted on the link.
-     *
-     *  Must be a power of two. */
+     *  memory but not yet transmitted on the link. */
     uint16_t                 u16FIFOS;
+    /** FIFO Watermark. */
+    uint16_t                 u16FIFOW;
     /** Last Valid Index (SDnLVI). */
     uint16_t                 u16LVI;
-    uint16_t                 Padding1[3];
+    uint16_t                 Padding1[2];
     /** Pointer to HDA sink this stream is attached to. */
     R3PTRTYPE(PHDAMIXERSINK) pMixSink;
@@ -827 +832 @@
      * Used to calculate the time actually elapsed between two timer callbacks. */
     uint64_t                           uTimerTS;
+    uint64_t                           uTimerMS;
 #endif
 #ifdef VBOX_WITH_STATISTICS
@@ -892 +898 @@
  */
 static int hdaRegWriteGCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
-static int hdaRegReadINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
 static int hdaRegReadLPIB(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
 static int hdaRegReadWALCLK(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
-//static int hdaRegReadSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value); - unused
-//static int hdaRegWriteSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);  - unused
-//static int hdaRegWriteINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value); - implementation not found.
 static int hdaRegWriteCORBWP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegWriteCORBRP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
@@ -905 +907 @@
 static int hdaRegWriteRIRBSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
+static int hdaRegWriteINTCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegWriteIRS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int hdaRegReadIRS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value);
@@ -917 +920 @@
 static int       hdaRegWriteSDSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int       hdaRegWriteSDLVI(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
-//static int       hdaRegWriteSDFIFOW(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value); - unused
-//static int       hdaRegWriteSDFIFOS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value); - unused
+static int       hdaRegWriteSDFIFOW(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
+static int       hdaRegWriteSDFIFOS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int       hdaRegWriteSDFMT(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
 static int       hdaRegWriteSDBDPL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value);
@@ -945 +948 @@
 /** @} */
 
+/** @name Stream functions.
+ * @{
+ */
 #ifdef IN_RING3
-static void hdaStreamDestroy(PHDASTREAM pStream);
-static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive);
-//static int hdaStreamStart(PHDASTREAM pStream); - unused
-static int hdaStreamStop(PHDASTREAM pStream);
-/*static int hdaStreamWaitForStateChange(PHDASTREAM pStream, RTMSINTERVAL msTimeout); - currently unused */
-static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcess, uint32_t *pcbProcessed);
-#endif
-
+static void          hdaStreamDestroy(PHDASTREAM pStream);
+static int           hdaStreamDoDMA(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf, uint32_t cbToProcess, uint32_t *pcbProcessed);
+static int           hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive);
+static int           hdaStreamUpdate(PHDASTATE pThis, PHDASTREAM pStream);
+DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB);
+#endif /* IN_RING3 */
+/** @} */
+
+/** @name Stream mapping functions.
+ * @{
+ */
 #ifdef IN_RING3
-static int hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg);
-static void hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping);
-static void hdaStreamMapReset(PHDASTREAMMAPPING pMapping);
-#endif
-
+static int           hdaStreamMapInit(PHDASTREAMMAPPING pMapping, PPDMAUDIOSTREAMCFG pCfg);
+static void          hdaStreamMapDestroy(PHDASTREAMMAPPING pMapping);
+static void          hdaStreamMapReset(PHDASTREAMMAPPING pMapping);
+#endif /* IN_RING3 */
+/** @} */
+
+/** @name HDA device functions.
+ * @{
+ */
+#ifdef IN_RING3
+static void          hdaDoTransfers(PHDASTATE pThis);
+#endif /* IN_RING3 */
+static int           hdaProcessInterrupt(PHDASTATE pThis);
+/** @} */
+
+/** @name BDLE (Buffer Descriptor List Entry) functions.
+ * @{
+ */
 #ifdef IN_RING3
 static int           hdaBDLEFetch(PHDASTATE pThis, PHDABDLE pBDLE, uint64_t u64BaseDMA, uint16_t u16Entry);
-DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB);
 # ifdef LOG_ENABLED
 static void          hdaBDLEDumpAll(PHDASTATE pThis, uint64_t u64BaseDMA, uint16_t cBDLE);
 # endif
-#endif
-static int           hdaProcessInterrupt(PHDASTATE pThis);
-
-/*
- * Timer routines.
+#endif /* IN_RING3 */
+/** @} */
+
+/** @name Timer functions.
+ * @{
  */
 #if !defined(VBOX_WITH_AUDIO_HDA_CALLBACKS) && defined(IN_RING3)
-static void hdaTimerMaybeStart(PHDASTATE pThis);
-static void hdaTimerMaybeStop(PHDASTATE pThis);
-#endif
+static void          hdaTimerMaybeStart(PHDASTATE pThis);
+static void          hdaTimerMaybeStop(PHDASTATE pThis);
+#endif
+/** @} */
 
 
@@ -1001 +1023 @@
     { offset,        0x00003, 0x00FF001F, 0x00F0001F, hdaRegReadU24 , hdaRegWriteSDCTL , HDA_REG_IDX_STRM(name, CTL)  , #name " Stream Descriptor Control" }, \
     /* Offset 0x83 (SD0) */ \
-    { offset + 0x3,  0x00001, 0x0000001C, 0x0000003C, hdaRegReadU8  , hdaRegWriteSDSTS , HDA_REG_IDX_STRM(name, STS)  , #name " Status" }, \
+    { offset + 0x3,  0x00001, 0x0000003C, 0x0000001C, hdaRegReadU8  , hdaRegWriteSDSTS , HDA_REG_IDX_STRM(name, STS)  , #name " Status" }, \
     /* Offset 0x84 (SD0) */ \
     { offset + 0x4,  0x00004, 0xFFFFFFFF, 0x00000000, hdaRegReadLPIB, hdaRegWriteU32   , HDA_REG_IDX_STRM(name, LPIB) , #name " Link Position In Buffer" }, \
@@ -1009 +1031 @@
     { offset + 0xC,  0x00002, 0x0000FFFF, 0x0000FFFF, hdaRegReadU16, hdaRegWriteSDLVI  , HDA_REG_IDX_STRM(name, LVI)  , #name " Last Valid Index" }, \
     /* Reserved: FIFO Watermark. ** @todo Document this! */ \
-    { offset + 0xE,  0x00002, 0x00000007, 0x00000007, hdaRegReadU16, hdaRegWriteU16,     HDA_REG_IDX_STRM(name, FIFOW), #name " FIFO Watermark" }, \
+    { offset + 0xE,  0x00002, 0x00000007, 0x00000007, hdaRegReadU16, hdaRegWriteSDFIFOW, HDA_REG_IDX_STRM(name, FIFOW), #name " FIFO Watermark" }, \
     /* Offset 0x90 (SD0) */ \
-    { offset + 0x10, 0x00002, 0x000000FF, 0x00000000, hdaRegReadU16, hdaRegWriteU16,     HDA_REG_IDX_STRM(name, FIFOS), #name " FIFO Size" }, \
+    { offset + 0x10, 0x00002, 0x000000FF, 0x000000FF, hdaRegReadU16, hdaRegWriteSDFIFOS, HDA_REG_IDX_STRM(name, FIFOS), #name " FIFO Size" }, \
     /* Offset 0x92 (SD0) */ \
     { offset + 0x12, 0x00002, 0x00007F7F, 0x00007F7F, hdaRegReadU16, hdaRegWriteSDFMT  , HDA_REG_IDX_STRM(name, FMT)  , #name " Stream Format" }, \
@@ -1061 +1083 @@
     { 0x00018, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteU16        , HDA_REG_IDX(OUTSTRMPAY)   }, /* Output Stream Payload Capability */
     { 0x0001A, 0x00002, 0x0000FFFF, 0x00000000, hdaRegReadU16          , hdaRegWriteUnimpl     , HDA_REG_IDX(INSTRMPAY)    }, /* Input Stream Payload Capability */
-    { 0x00020, 0x00004, 0xC00000FF, 0xC00000FF, hdaRegReadU32          , hdaRegWriteU32        , HDA_REG_IDX(INTCTL)       }, /* Interrupt Control */
-    { 0x00024, 0x00004, 0xC00000FF, 0x00000000, hdaRegReadINTSTS       , hdaRegWriteUnimpl     , HDA_REG_IDX(INTSTS)       }, /* Interrupt Status */
+    { 0x00020, 0x00004, 0xC00000FF, 0xC00000FF, hdaRegReadU32          , hdaRegWriteINTCTL     , HDA_REG_IDX(INTCTL)       }, /* Interrupt Control */
+    { 0x00024, 0x00004, 0xC00000FF, 0x00000000, hdaRegReadU32          , hdaRegWriteUnimpl     , HDA_REG_IDX(INTSTS)       }, /* Interrupt Status */
     { 0x00030, 0x00004, 0xFFFFFFFF, 0x00000000, hdaRegReadWALCLK       , hdaRegWriteUnimpl     , HDA_REG_IDX_LOCAL(WALCLK) }, /* Wall Clock Counter */
     { 0x00034, 0x00004, 0x000000FF, 0x000000FF, hdaRegReadU32          , hdaRegWriteU32        , HDA_REG_IDX(SSYNC)        }, /* Stream Synchronization */
@@ -1133 +1155 @@
     SSMFIELD_ENTRY(HDABDLESTATE, u32BDLIndex),
     SSMFIELD_ENTRY(HDABDLESTATE, cbBelowFIFOW),
-    SSMFIELD_ENTRY(HDABDLESTATE, au8FIFO),
+    SSMFIELD_ENTRY_OLD(FIFO, 256),
     SSMFIELD_ENTRY(HDABDLESTATE, u32BufOff),
     SSMFIELD_ENTRY_TERM()
@@ -1143 +1165 @@
     SSMFIELD_ENTRY_OLD(cBDLE, 2),
     SSMFIELD_ENTRY(HDASTREAMSTATE, uCurBDLE),
-    SSMFIELD_ENTRY(HDASTREAMSTATE, fDoStop),
-    SSMFIELD_ENTRY(HDASTREAMSTATE, fActive),
+    SSMFIELD_ENTRY_OLD(fDoStop, 1),
+    SSMFIELD_ENTRY_OLD(fActive, 1),
     SSMFIELD_ENTRY(HDASTREAMSTATE, fInReset),
     SSMFIELD_ENTRY_TERM()
@@ -1157 +1179 @@
     UINT32_C(0), UINT32_C(0x000000ff), UINT32_C(0x0000ffff), UINT32_C(0x00ffffff), UINT32_C(0xffffffff)
 };
-
-#ifdef IN_RING3
-
-DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB)
-{
-    AssertPtrReturn(pThis,   0);
-    AssertPtrReturn(pStream, 0);
-
-    Assert(u32LPIB <= pStream->u32CBL);
-
-    LogFlowFunc(("[SD%RU8]: LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",
-                 pStream->u8SD, u32LPIB, pThis->fDMAPosition));
-
-    /* Update LPIB in any case. */
-    HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) = u32LPIB;
-
-    /* Do we need to tell the current DMA position? */
-    if (pThis->fDMAPosition)
-    {
-        int rc2 = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
-                                        (pThis->u64DPBase & DPBASE_ADDR_MASK) + (pStream->u8SD * 2 * sizeof(uint32_t)),
-                                        (void *)&u32LPIB, sizeof(uint32_t));
-        AssertRC(rc2);
-    }
-
-    return u32LPIB;
-}
 
 
@@ -1218 +1213 @@
 
 
-# if defined(IN_RING3) && (defined(DEBUG) || defined(VBOX_HDA_WITH_FIFO))
 /**
  * Retrieves the number of bytes of a FIFOW register.
@@ -1238 +1232 @@
     return cb;
 }
-#endif
+
+
+#ifdef IN_RING3
+DECLINLINE(uint32_t) hdaStreamUpdateLPIB(PHDASTATE pThis, PHDASTREAM pStream, uint32_t u32LPIB)
+{
+    AssertPtrReturn(pThis,   0);
+    AssertPtrReturn(pStream, 0);
+
+    AssertMsg(u32LPIB <= pStream->u32CBL,
+              ("[SD%RU8] New LPIB (%RU32) exceeds CBL (%RU32)\n", pStream->u8SD, u32LPIB, pStream->u32CBL));
+
+    u32LPIB = RT_MIN(u32LPIB, pStream->u32CBL);
+
+    LogFlowFunc(("[SD%RU8]: LPIB=%RU32 (DMA Position Buffer Enabled: %RTbool)\n",
+                 pStream->u8SD, u32LPIB, pThis->fDMAPosition));
+
+    /* Update LPIB in any case. */
+    HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) = u32LPIB;
+
+    /* Do we need to tell the current DMA position? */
+    if (pThis->fDMAPosition)
+    {
+        int rc2 = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
+                                        (pThis->u64DPBase & DPBASE_ADDR_MASK) + (pStream->u8SD * 2 * sizeof(uint32_t)),
+                                        (void *)&u32LPIB, sizeof(uint32_t));
+        AssertRC(rc2);
+    }
+
+    return u32LPIB;
+}
 
 
@@ -1246 +1269 @@
  * @return  IPRT status code.
  */
-DECLINLINE(int) hdaStreamGetNextBDLE(PHDASTATE pThis, PHDASTREAM pStream)
+DECLINLINE(int) hdaStreamGetNextBDLE(PHDASTATE pThis, PHDASTREAM pStream, bool *pfWrapAround)
 {
     AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
@@ -1261 +1284 @@
 # endif
 
-    PHDABDLE pBDLE = &pStream->State.BDLE;
+    PHDABDLE pBDLE       = &pStream->State.BDLE;
+    bool     fWrapAround = false;
+
+    AssertMsg(pBDLE->State.u32BufOff == pBDLE->u32BufSize, ("BDLE not finished yet: %R[bdle]\n", pBDLE));
 
     /*
@@ -1271 +1297 @@
     {
         pStream->State.uCurBDLE = 0;
-
-        hdaStreamUpdateLPIB(pThis, pStream, 0);
+        fWrapAround = true;
     }
 
@@ -1279 +1304 @@
     /* Fetch the next BDLE entry. */
     int rc = hdaBDLEFetch(pThis, pBDLE, pStream->u64BDLBase, pStream->State.uCurBDLE);
-
-    LogFlowFunc(("[SD%RU8]: uOldBDLE=%RU16, uCurBDLE=%RU16, LVI=%RU32, rc=%Rrc, %R[bdle]\n",
-                 pStream->u8SD, uOldBDLE, pStream->State.uCurBDLE, pStream->u16LVI, rc, pBDLE));
+    if (RT_SUCCESS(rc))
+    {
+        LogFlowFunc(("[SD%RU8]: uOldBDLE=%RU16, uCurBDLE=%RU16, LVI=%RU32, rc=%Rrc, %R[bdle]\n",
+                     pStream->u8SD, uOldBDLE, pStream->State.uCurBDLE, pStream->u16LVI, rc, pBDLE));
+
+        if (pfWrapAround)
+            *pfWrapAround = fWrapAround;
+    }
+
     return rc;
 }
 
+
+/**
+ * Returns the HDA stream of specified stream descriptor number.
+ *
+ * @return  Pointer to HDA stream, or NULL if none found.
+ */
+DECLINLINE(PHDASTREAM) hdaStreamFromSD(PHDASTATE pThis, uint8_t uSD)
+{
+    AssertPtrReturn(pThis, NULL);
+    AssertReturn(uSD <= HDA_MAX_STREAMS, NULL);
+
+    if (uSD >= HDA_MAX_STREAMS)
+        return NULL;
+
+    return &pThis->aStreams[uSD];
+}
+
+
+/**
+ * Returns the HDA stream of specified HDA sink.
+ *
+ * @return  Pointer to HDA stream, or NULL if none found.
+ */
+DECLINLINE(PHDASTREAM) hdaSinkGetStream(PHDASTATE pThis, PHDAMIXERSINK pSink)
+{
+    AssertPtrReturn(pThis, NULL);
+    AssertPtrReturn(pSink, NULL);
+
+    /** @todo Do something with the channel mapping here? */
+    return hdaStreamFromSD(pThis, pSink->uSD);
+}
+
+/**
+ * Retrieves the minimum number of bytes accumulated/free in the
+ * FIFO before the controller will start a fetch/eviction of data.
+ *
+ * Uses SDFIFOW (FIFO Watermark Register).
+ *
+ * @return Number of bytes accumulated/free in the FIFO.
+ */
+DECLINLINE(uint8_t) hdaStreamGetFIFOW(PHDASTATE pThis, PHDASTREAM pStream)
+{
+    AssertPtrReturn(pThis, 0);
+    AssertPtrReturn(pStream, 0);
+
+# ifdef VBOX_HDA_WITH_FIFO
+    return hdaSDFIFOWToBytes(HDA_STREAM_REG(pThis, FIFOW, pStream->u8SD));
+# else
+    return 0;
+# endif
+}
+
+#endif /* IN_RING3 */
 
 /**
@@ -1308 +1392 @@
 }
 
-
-/**
- * Returns the HDA stream of specified stream descriptor number.
- *
- * @return  Pointer to HDA stream, or NULL if none found.
- */
-DECLINLINE(PHDASTREAM) hdaStreamFromSD(PHDASTATE pThis, uint8_t uSD)
-{
-    AssertPtrReturn(pThis, NULL);
-    AssertReturn(uSD <= HDA_MAX_STREAMS, NULL);
-
-    if (uSD >= HDA_MAX_STREAMS)
-        return NULL;
-
-    return &pThis->aStreams[uSD];
-}
-
-
-/**
- * Returns the HDA stream of specified HDA sink.
- *
- * @return  Pointer to HDA stream, or NULL if none found.
- */
-DECLINLINE(PHDASTREAM) hdaGetStreamFromSink(PHDASTATE pThis, PHDAMIXERSINK pSink)
-{
-    AssertPtrReturn(pThis, NULL);
-    AssertPtrReturn(pSink, NULL);
-
-    /** @todo Do something with the channel mapping here? */
-    return hdaStreamFromSD(pThis, pSink->uSD);
-}
-
-/**
- * Retrieves the minimum number of bytes accumulated/free in the
- * FIFO before the controller will start a fetch/eviction of data.
- *
- * Uses SDFIFOW (FIFO Watermark Register).
- *
- * @return Number of bytes accumulated/free in the FIFO.
- */
-DECLINLINE(uint8_t) hdaStreamGetFIFOW(PHDASTATE pThis, PHDASTREAM pStream)
-{
-    AssertPtrReturn(pThis, 0);
-    AssertPtrReturn(pStream, 0);
-
-# ifdef VBOX_HDA_WITH_FIFO
-    return hdaSDFIFOWToBytes(HDA_STREAM_REG(pThis, FIFOW, pStream->u8SD));
-# else
-    return 0;
-# endif
-}
-
-#endif /* IN_RING3 */
+static void hdaUpdateINTSTS(PHDASTATE pThis)
+{
+    uint32_t intSts = 0;
+
+    if (/* Response Overrun Interrupt Status (ROIS) */
+           HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
+        /* Response Interrupt */
+        || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
+        /* SDIN State Change Status Flags (SCSF) */
+        || (HDA_REG(pThis, STATESTS) & HDA_STATESTS_SCSF_MASK))
+    {
+        intSts |= RT_BIT(30); /* Touch Controller Interrupt Status (CIS). */
+    }
+
+#define HDA_MARK_STREAM(x)                                                  \
+        if (   (INTCTL_SX(pThis, x))                                        \
+            && (   (SDSTS(pThis, x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE))   \
+                || (SDSTS(pThis, x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE))   \
+                || (SDSTS(pThis, x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)) \
+               )                                                            \
+           )                                                                \
+    {                                                                       \
+        Log3Func(("[SD%RU8] Marked\n", x));                                 \
+        intSts |= RT_BIT(x);                                                \
+    }
+
+    HDA_MARK_STREAM(0);
+    HDA_MARK_STREAM(1);
+    HDA_MARK_STREAM(2);
+    HDA_MARK_STREAM(3);
+    HDA_MARK_STREAM(4);
+    HDA_MARK_STREAM(5);
+    HDA_MARK_STREAM(6);
+    HDA_MARK_STREAM(7);
+
+#undef HDA_MARK_STREAM
+
+    if (intSts)
+        intSts |= RT_BIT(31); /* Touch Global Interrupt Status (GIS). */
+
+    HDA_REG(pThis, INTSTS) = intSts;
+
+    Log3Func(("INTSTS=%x\n", intSts));
+}
 
 static int hdaProcessInterrupt(PHDASTATE pThis)
 {
-#define IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, num) \
-        (   INTCTL_SX((pThis), num) \
-         && (SDSTS(pThis, num) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
+    hdaUpdateINTSTS(pThis);
 
     int iLevel = 0;
 
-    /** @todo Optimize IRQ handling. */
-
-    if (/* Controller Interrupt Enable (CIE). */
-          HDA_REG_FLAG_VALUE(pThis, INTCTL, CIE)
-       && (   HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
-           || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
-           || (HDA_REG(pThis, STATESTS) & HDA_REG(pThis, WAKEEN))))
-    {
+    /* Global Interrupt Status (GIS) touched? */
+    if (HDA_REG_FLAG_VALUE(pThis, INTSTS, GIS))
         iLevel = 1;
-    }
-
-    if (   IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 0)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 1)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 2)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 3)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 4)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 5)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 6)
-        || IS_INTERRUPT_OCCURED_AND_ENABLED(pThis, 7))
-    {
-        iLevel = 1;
-    }
-
+
+    Log3Func(("INTCTL=%x, INTSTS=%x, Level=%d\n", HDA_REG(pThis, INTCTL), HDA_REG(pThis, INTSTS), iLevel));
+
+    /* Global Interrupt Enable (GIE) set? */
     if (HDA_REG_FLAG_VALUE(pThis, INTCTL, GIE))
-    {
-        Log3Func(("Level=%d\n", iLevel));
-        PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0 , iLevel);
-    }
-
-#undef IS_INTERRUPT_OCCURED_AND_ENABLED
+        PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0, iLevel);
 
     return VINF_SUCCESS;
@@ -1638 +1690 @@
     AssertReturn(uSD <= HDA_MAX_STREAMS, VERR_INVALID_PARAMETER);
 
-    int rc = RTSemEventCreate(&pStream->State.hStateChangedEvent);
-    if (RT_SUCCESS(rc))
-        rc = RTCritSectInit(&pStream->State.CritSect);
-
+    int rc = RTCritSectInit(&pStream->State.CritSect);
     if (RT_SUCCESS(rc))
     {
@@ -1647 +1696 @@
         pStream->pMixSink       = NULL;
 
-        pStream->State.fActive  = false;
         pStream->State.fInReset = false;
-        pStream->State.fDoStop  = false;
-    }
+    }
+
+    if (RT_SUCCESS(rc))
+        rc = RTCircBufCreate(&pStream->State.pCircBuf, HDA_FIFO_MAX);
 
     LogFlowFunc(("uSD=%RU8\n", uSD));
@@ -1662 +1712 @@
     LogFlowFunc(("[SD%RU8]: Destroying ...\n", pStream->u8SD));
 
-    int rc2 = hdaStreamStop(pStream);
+    hdaStreamMapDestroy(&pStream->State.Mapping);
+
+    int rc2 = RTCritSectDelete(&pStream->State.CritSect);
     AssertRC(rc2);
 
-    hdaStreamMapDestroy(&pStream->State.Mapping);
-
-    rc2 = RTCritSectDelete(&pStream->State.CritSect);
-    AssertRC(rc2);
-
-    if (pStream->State.hStateChangedEvent != NIL_RTSEMEVENT)
-    {
-        rc2 = RTSemEventDestroy(pStream->State.hStateChangedEvent);
-        AssertRC(rc2);
-        pStream->State.hStateChangedEvent = NIL_RTSEMEVENT;
+    if (pStream->State.pCircBuf)
+    {
+        RTCircBufDestroy(pStream->State.pCircBuf);
+        pStream->State.pCircBuf = NULL;
     }
 
@@ -1739 +1785 @@
     RT_ZERO(pStream->State.BDLE);
     pStream->State.uCurBDLE = 0;
+
+    if (pStream->State.pCircBuf)
+        RTCircBufReset(pStream->State.pCircBuf);
+#if 0
+    RT_ZERO(pStream->State.abFIFO);
+    pStream->State.cbFIFOUsed = 0;
+    pStream->State.cbFIFOOff  = 0;
+#endif
 
     /*
@@ -1747 +1801 @@
      * bits are reserved for stream number 18.2.33, resets SDnCTL except SRST bit. */
     HDA_STREAM_REG(pThis, CTL,   uSD) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
-    /* ICH6 defines default values (0x77 for input and 0xBF for output descriptors) of FIFO size. 18.2.39. */
-    HDA_STREAM_REG(pThis, FIFOS, uSD) = hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN ? HDA_SDIFIFO_120B : HDA_SDOFIFO_192B;
+    /*
+     * ICH6 defines default values (120 bytes for input and 192 bytes for output descriptors) of FIFO size. 18.2.39.
+     * BUT: Windows guests seem to read the FIFOS but define a DMA region which does not fit to that FIFO size
+     *      (e.g. 1792 bytes DMA region vs. 192 bytes FIFOS).
+     *      This will lead to crackling and corrupted sound -- so define a 256 bytes FIOS for output streams here per default.
+     */
+    HDA_STREAM_REG(pThis, FIFOS, uSD) = hdaGetDirFromSD(uSD) == PDMAUDIODIR_IN ? HDA_SDIFIFO_120B : HDA_SDOFIFO_256B;
     /* See 18.2.38: Always defaults to 0x4 (32 bytes). */
     HDA_STREAM_REG(pThis, FIFOW, uSD) = HDA_SDFIFOW_32B;
@@ -1763 +1822 @@
     AssertRC(rc2);
 
-    /* Report that we're done resetting this stream. */
-    HDA_STREAM_REG(pThis, CTL,   uSD) = 0;
-
     /* Exit reset state. */
     ASMAtomicXchgBool(&pStream->State.fInReset, false);
 }
 
-# if 0 /* unused */
-static bool hdaStreamIsActive(PHDASTATE pThis, PHDASTREAM pStream)
-{
-    AssertPtrReturn(pThis,   false);
-    AssertPtrReturn(pStream, false);
-
-    bool fActive = pStream->State.fActive;
-
-    LogFlowFunc(("SD=%RU8, fActive=%RTbool\n", pStream->u8SD, fActive));
-    return fActive;
-}
-# endif
-
 static int hdaStreamSetActive(PHDASTATE pThis, PHDASTREAM pStream, bool fActive)
 {
@@ -1789 +1832 @@
 
     LogFlowFunc(("[SD%RU8]: fActive=%RTbool, pMixSink=%p\n", pStream->u8SD, fActive, pStream->pMixSink));
-
-    if (pStream->State.fActive == fActive) /* No change required? */
-    {
-        LogFlowFunc(("[SD%RU8]: No change\n", pStream->u8SD));
-        return VINF_SUCCESS;
-    }
 
     int rc = VINF_SUCCESS;
@@ -1815 +1852 @@
         return rc;
     }
-
-    pStream->State.fActive = fActive;
 
     /* Second, see if we need to start or stop the timer. */
@@ -1852 +1887 @@
         AssertRC(rc2);
     }
-}
-
-# if 0 /** @todo hdaStreamStart is unused */
-static int hdaStreamStart(PHDASTREAM pStream)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    ASMAtomicXchgBool(&pStream->State.fDoStop, false);
-    ASMAtomicXchgBool(&pStream->State.fActive, true);
-
-    LogFlowFuncLeave();
-    return VINF_SUCCESS;
-}
-# endif /* unused */
-
-static int hdaStreamStop(PHDASTREAM pStream)
-{
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
-
-    /* Already in stopped state? */
-    bool fActive = ASMAtomicReadBool(&pStream->State.fActive);
-    if (!fActive)
-        return VINF_SUCCESS;
-
-# if 0 /** @todo Does not work (yet), as EMT deadlocks then. */
-    /*
-     * Wait for the stream to stop.
-     */
-    ASMAtomicXchgBool(&pStream->State.fDoStop, true);
-
-    int rc = hdaStreamWaitForStateChange(pStream, 60 * 1000 /* ms timeout */);
-    fActive = ASMAtomicReadBool(&pStream->State.fActive);
-    if (   /* Waiting failed? */
-           RT_FAILURE(rc)
-           /* Stream is still active? */
-        || fActive)
-    {
-        AssertRC(rc);
-        LogRel(("HDA: Warning: Unable to stop stream %RU8 (state: %s), rc=%Rrc\n",
-                pStream->u8Strm, fActive ? "active" : "stopped", rc));
-    }
-# else
-    int rc = VINF_SUCCESS;
-# endif
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
 }
 
@@ -2147 +2135 @@
 static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
-
-    uint32_t v = pThis->au32Regs[iRegMem];
-    uint32_t nv = u32Value & HDA_STATES_SCSF;
-    pThis->au32Regs[iRegMem] &= ~(v & nv); /* write of 1 clears corresponding bit */
-    return VINF_SUCCESS;
-}
-
-static int hdaRegReadINTSTS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
-{
-    RT_NOREF_PV(iReg);
-
-    uint32_t v = 0;
-    if (   HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
-        || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
-        || HDA_REG_FLAG_VALUE(pThis, CORBSTS, CMEI)
-        || HDA_REG(pThis, STATESTS))
-    {
-        v |= RT_BIT(30); /* Touch CIS. */
-    }
-
-#define HDA_MARK_STREAM(x)                                             \
-    if (/* Descriptor Error */                                         \
-           (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, DE))    \
-        /* FIFO Error */                                               \
-        || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, FE))    \
-        /* Buffer Completion Interrupt Status */                       \
-        || (SDSTS((pThis), x) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS))) \
-    {                                                                  \
-        Log3Func(("[SD%RU8] BCIS: Marked\n", x));                      \
-        v |= RT_BIT(x);                                                \
-    }
-
-    HDA_MARK_STREAM(0);
-    HDA_MARK_STREAM(1);
-    HDA_MARK_STREAM(2);
-    HDA_MARK_STREAM(3);
-    HDA_MARK_STREAM(4);
-    HDA_MARK_STREAM(5);
-    HDA_MARK_STREAM(6);
-    HDA_MARK_STREAM(7);
-
-#undef HDA_MARK_STREAM
-
-    /* "OR" bit of all interrupt status bits. */
-    v |= v ? RT_BIT(31) : 0;
-
-    *pu32Value = v;
-    return VINF_SUCCESS;
+    uint32_t v  = HDA_REG_IND(pThis, iReg);
+    uint32_t nv = u32Value & HDA_STATESTS_SCSF_MASK;
+
+    HDA_REG(pThis, STATESTS) &= ~(v & nv); /* Write of 1 clears corresponding bit. */
+
+    return hdaProcessInterrupt(pThis);
+}
+
+static int hdaRegWriteINTCTL(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
+{
+    RT_NOREF(iReg);
+
+    HDA_REG(pThis, INTCTL) = u32Value;
+
+    return hdaProcessInterrupt(pThis);
 }
 
@@ -2221 +2175 @@
     return VINF_SUCCESS;
 }
-
-#if 0 /** @todo hdaRegReadSSYNC &  hdaRegWriteSSYNC are unused */
-
-static int hdaRegReadSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
-{
-    RT_NOREF_PV(iReg);
-
-    /* HDA spec (1a): 3.3.16 WALCLK counter ticks with 24Mhz bitclock rate. */
-    *pu32Value = HDA_REG(pThis, SSYNC);
-    LogFlowFunc(("%RU32\n", *pu32Value));
-    return VINF_SUCCESS;
-}
-
-static int hdaRegWriteSSYNC(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
-{
-    LogFlowFunc(("%RU32\n", u32Value));
-    return hdaRegWriteU32(pThis, iReg, u32Value);
-}
-
-#endif /* unused */
 
 static int hdaRegWriteCORBRP(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
@@ -2340 +2274 @@
 {
 #ifdef IN_RING3
+    /*
+     * Some guests write too much (that is, 32-bit with the top 8 bit being junk)
+     * instead of 24-bit required for SDCTL. So just mask this here to be safe.
+     */
+    u32Value = (u32Value & 0x00ffffff);
+
     bool fRun      = RT_BOOL(u32Value & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
     bool fInRun    = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
@@ -2346 +2286 @@
     bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
 
+    /* Get the stream descriptor. */
+    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, CTL, iReg);
+
+    LogFunc(("[SD%RU8]: fRun=%RTbool, fInRun=%RTbool, fReset=%RTbool, fInReset=%RTbool, %R[sdctl]\n",
+             uSD, fRun, fInRun, fReset, fInReset, u32Value));
+
     if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
         return VINF_SUCCESS; /* Always return success to the MMIO handler. */
-
-    /* Get the stream descriptor. */
-    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, CTL, iReg);
 
     /*
@@ -2382 +2325 @@
     AssertRC(rc2);
 
-    LogFunc(("[SD%RU8]: fRun=%RTbool, fInRun=%RTbool, fReset=%RTbool, fInReset=%RTbool, %R[sdctl]\n",
-             uSD, fRun, fInRun, fReset, fInReset, u32Value));
-
     if (fInReset)
     {
@@ -2401 +2341 @@
 
         LogFunc(("[SD%RU8]: Guest initiated enter to stream reset\n", pStream->u8SD));
+
         hdaStreamReset(pThis, pStream);
     }
@@ -2422 +2363 @@
             }
         }
-
-        if (!fInRun && !fRun)
-            hdaStreamInit(pThis, pStream, pStream->u8SD);
-    }
+    }
+
+    rc2 = hdaRegWriteU24(pThis, iReg, u32Value);
+    AssertRC(rc2);
 
     /* Make sure to handle interrupts here as well. */
     hdaProcessInterrupt(pThis);
-
-    rc2 = hdaRegWriteU24(pThis, iReg, u32Value);
-    AssertRC(rc2);
 
     hdaRegWriteSDUnlock(pStream);
@@ -2443 +2381 @@
 static int hdaRegWriteSDSTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    uint32_t v  = HDA_REG_IND(pThis, iReg);
-             /* Clear (zero) FIFOE and DESE bits when writing 1 to it. */
-             v &= ~(u32Value & v);
-
-    HDA_REG_IND(pThis, iReg) = v;
+    uint32_t v = HDA_REG_IND(pThis, iReg);
+
+    /* Clear (zero) FIFOE, DESE and BCIS bits when writing 1 to it (6.2.33). */
+    HDA_REG_IND(pThis, iReg) &= ~(u32Value & v);
+
+    LogFunc(("SDSTS 0x%x -> 0x%x\n", v, HDA_REG_IND(pThis, iReg)));
 
     hdaProcessInterrupt(pThis);
-    return VINF_SUCCESS;
+    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
 }
 
@@ -2459 +2398 @@
         return VINF_SUCCESS;
 
-    PHDASTREAM pStream = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, LVI, iReg));
+    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, LVI, iReg);
+
+    PHDASTREAM pStream = hdaStreamFromSD(pThis, uSD);
     if (!pStream)
     {
-        LogFunc(("[SD%RU8]: Warning: Changing SDLVI on non-attached stream (0x%x)\n", HDA_SD_NUM_FROM_REG(pThis, CTL, iReg), u32Value));
+        AssertMsgFailed(("[SD%RU8]: Warning: Changing SDLVI on non-attached stream (0x%x)\n", uSD, u32Value));
         return hdaRegWriteU16(pThis, iReg, u32Value);
     }
 
     int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
-    AssertRC(rc2);
-
-    /** @todo Validate LVI. */
-    pStream->u16LVI = u32Value;
-
-    /* Reset BDLE state. */
-    RT_ZERO(pStream->State.BDLE);
-    pStream->State.uCurBDLE = 0;
-
-    rc2 = hdaRegWriteU16(pThis, iReg, u32Value);
-    AssertRC(rc2);
-
-    LogFlowFunc(("[SD%RU8]: LVI=%RU32\n", pStream->u8SD, u32Value));
-    hdaRegWriteSDUnlock(pStream);
+    if (RT_SUCCESS(rc2))
+    {
+        /** @todo Validate LVI. */
+        pStream->u16LVI = u32Value;
+        LogFunc(("[SD%RU8]: Updating LVI to %RU32\n", uSD, pStream->u16LVI));
+
+        /* Reset BDLE state. */
+        RT_ZERO(pStream->State.BDLE);
+        pStream->State.uCurBDLE = 0;
+
+        rc2 = hdaRegWriteU16(pThis, iReg, u32Value);
+        AssertRC(rc2);
+
+        hdaRegWriteSDUnlock(pStream);
+    }
+    else
+        LogRel(("HDA: Warning: Guest tried to write LVI to running stream #%RU8, ignoring\n", uSD));
 
     return VINF_SUCCESS; /* Always return success to the MMIO handler. */
@@ -2490 +2434 @@
 }
 
-#if 0 /** @todo hdaRegWriteSDFIFOW & hdaRegWriteSDFIFOS are unused */
 static int hdaRegWriteSDFIFOW(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    uint8_t  uSD      = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
-    /** @todo Only allow updating FIFOS if RUN bit is 0? */
-    uint32_t u32FIFOW = 0;
+#ifdef IN_RING3
+    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
 
     if (hdaGetDirFromSD(uSD) != PDMAUDIODIR_IN) /* FIFOW for input streams only. */
     {
-        LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to stream #%RU8, ignoring\n", uSD));
+        LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to output stream #%RU8, ignoring\n", uSD));
         return VINF_SUCCESS;
     }
 
-    switch (u32Value)
-    {
-        case HDA_SDFIFOW_8B:
-        case HDA_SDFIFOW_16B:
-        case HDA_SDFIFOW_32B:
-            u32FIFOW = u32Value;
-            break;
-        default:
-            LogRel(("HDA: Warning: Guest tried write unsupported FIFOW (0x%x) to stream #%RU8, defaulting to 32 bytes\n",
-                    u32Value, uSD));
-            u32FIFOW = HDA_SDFIFOW_32B;
-            break;
-    }
-
-    if (u32FIFOW)
-    {
-        LogFunc(("[SD%RU8]: Updating FIFOW to %RU32 bytes\n", uSD, hdaSDFIFOSToBytes(u32FIFOW)));
-        /** @todo Update internal stream state with new FIFOS. */
-
-        return hdaRegWriteU16(pThis, iReg, u32FIFOW);
-    }
-
-    return VINF_SUCCESS; /* Never reached. */
+    PHDASTREAM pStream = hdaStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg));
+    if (!pStream)
+    {
+        AssertMsgFailed(("[SD%RU8]: Warning: Changing FIFOW on non-attached stream (0x%x)\n", uSD, u32Value));
+        return hdaRegWriteU16(pThis, iReg, u32Value);
+    }
+
+    int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
+    if (RT_SUCCESS(rc2))
+    {
+        uint32_t u32FIFOW = 0;
+
+        switch (u32Value)
+        {
+            case HDA_SDFIFOW_8B:
+            case HDA_SDFIFOW_16B:
+            case HDA_SDFIFOW_32B:
+                u32FIFOW = u32Value;
+                break;
+            default:
+                LogRel(("HDA: Warning: Guest tried write unsupported FIFOW (0x%x) to stream #%RU8, defaulting to 32 bytes\n",
+                        u32Value, uSD));
+                AssertFailed();
+                u32FIFOW = HDA_SDFIFOW_32B;
+                break;
+        }
+
+        if (u32FIFOW)
+        {
+            pStream->u16FIFOW = hdaSDFIFOWToBytes(u32FIFOW);
+            LogFunc(("[SD%RU8]: Updating FIFOW to %RU32 bytes\n", uSD, pStream->u16FIFOW));
+
+            rc2 = hdaRegWriteU16(pThis, iReg, u32FIFOW);
+            AssertRC(rc2);
+        }
+
+        hdaRegWriteSDUnlock(pStream);
+    }
+    else
+        LogRel(("HDA: Warning: Guest tried to write FIFOW to running stream #%RU8, ignoring\n", uSD));
+
+    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
+#else  /* !IN_RING3 */
+    RT_NOREF_PV(pThis); RT_NOREF_PV(iReg); RT_NOREF_PV(u32Value);
+    return VINF_IOM_R3_MMIO_WRITE;
+#endif /* IN_RING3 */
 }
 
 /**
- * @note This method could be called for changing value on Output Streams
- *       only (ICH6 datasheet 18.2.39).
+ * @note This method could be called for changing value on Output Streams only (ICH6 datasheet 18.2.39).
  */
 static int hdaRegWriteSDFIFOS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    uint8_t  uSD      = HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg);
-    /** @todo Only allow updating FIFOS if RUN bit is 0? */
-    uint32_t u32FIFOS = 0;
+#ifdef IN_RING3
+    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg);
 
     if (hdaGetDirFromSD(uSD) != PDMAUDIODIR_OUT) /* FIFOS for output streams only. */
     {
-        LogRel(("HDA: Warning: Guest tried to write read-only FIFOS to stream #%RU8, ignoring\n", uSD));
+        LogRel(("HDA: Warning: Guest tried to write read-only FIFOS to input stream #%RU8, ignoring\n", uSD));
         return VINF_SUCCESS;
     }
 
-    switch(u32Value)
-    {
-        case HDA_SDOFIFO_16B:
-        case HDA_SDOFIFO_32B:
-        case HDA_SDOFIFO_64B:
-        case HDA_SDOFIFO_128B:
-        case HDA_SDOFIFO_192B:
-            u32FIFOS = u32Value;
-            break;
-
-        case HDA_SDOFIFO_256B: /** @todo r=andy Investigate this. */
-            LogFunc(("256-bit is unsupported, HDA is switched into 192-bit mode\n"));
-            /* Fall through is intentional. */
-        default:
-            LogRel(("HDA: Warning: Guest tried write unsupported FIFOS (0x%x) to stream #%RU8, defaulting to 192 bytes\n",
-                    u32Value, uSD));
-            u32FIFOS = HDA_SDOFIFO_192B;
-            break;
-    }
-
-    if (u32FIFOS)
-    {
-        LogFunc(("[SD%RU8]: Updating FIFOS to %RU32 bytes\n",
-                 HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg), hdaSDFIFOSToBytes(u32FIFOS)));
-        /** @todo Update internal stream state with new FIFOS. */
-
-        return hdaRegWriteU16(pThis, iReg, u32FIFOS);
-    }
-
-    return VINF_SUCCESS;
-}
-
-#endif /* unused */
+    PHDASTREAM pStream = hdaStreamFromSD(pThis, uSD);
+    if (!pStream)
+    {
+        AssertMsgFailed(("[SD%RU8]: Warning: Changing FIFOS on non-attached stream (0x%x)\n", uSD, u32Value));
+        return hdaRegWriteU16(pThis, iReg, u32Value);
+    }
+
+    int rc2 = hdaRegWriteSDLock(pThis, pStream, iReg, u32Value);
+    if (RT_SUCCESS(rc2))
+    {
+        uint32_t u32FIFOS = 0;
+
+        switch(u32Value)
+        {
+            case HDA_SDOFIFO_16B:
+            case HDA_SDOFIFO_32B:
+            case HDA_SDOFIFO_64B:
+            case HDA_SDOFIFO_128B:
+            case HDA_SDOFIFO_192B:
+            case HDA_SDOFIFO_256B:
+                u32FIFOS = u32Value;
+                break;
+
+            default:
+                LogRel(("HDA: Warning: Guest tried write unsupported FIFOS (0x%x) to stream #%RU8, defaulting to 192 bytes\n",
+                        u32Value, uSD));
+                AssertFailed();
+                u32FIFOS = HDA_SDOFIFO_192B;
+                break;
+        }
+
+        if (u32FIFOS)
+        {
+            pStream->u16FIFOS = hdaSDFIFOSToBytes(u32FIFOS);
+            LogFunc(("[SD%RU8]: Updating FIFOS to %RU32 bytes\n", uSD, pStream->u16FIFOS));
+
+            rc2 = hdaRegWriteU16(pThis, iReg, u32FIFOS);
+            AssertRC(rc2);
+        }
+
+        hdaRegWriteSDUnlock(pStream);
+    }
+    else
+        LogRel(("HDA: Warning: Guest tried to write FIFOS to running stream #%RU8, ignoring\n", uSD));
+
+     return VINF_SUCCESS; /* Always return success to the MMIO handler. */
+#else  /* !IN_RING3 */
+    RT_NOREF_PV(pThis); RT_NOREF_PV(iReg); RT_NOREF_PV(u32Value);
+    return VINF_IOM_R3_MMIO_WRITE;
+#endif /* IN_RING3 */
+}
 
 #ifdef IN_RING3
@@ -3242 +3223 @@
     AssertPtrReturn(pThis,   0);
     AssertPtrReturn(pStream, 0);
-
-    if (!cbMax)
-        return 0;
+    AssertReturn   (cbMax,   0);
 
     PHDABDLE pBDLE = &pStream->State.BDLE;
@@ -3251 +3230 @@
     Assert(u32LPIB <= pStream->u32CBL);
 
-    uint32_t cbFree = pStream->u32CBL - u32LPIB;
-    if (cbFree)
-    {
-        /* Limit to the available free space of the current BDLE. */
-        cbFree = RT_MIN(cbFree, pBDLE->u32BufSize - pBDLE->State.u32BufOff);
-
-        /* Make sure we only copy as much as the stream's FIFO can hold (SDFIFOS, 18.2.39). */
-        cbFree = RT_MIN(cbFree, uint32_t(pStream->u16FIFOS));
-
-        /* Make sure we only transfer as many bytes as requested. */
-        cbFree = RT_MIN(cbFree, cbMax);
-
-        if (pBDLE->State.cbBelowFIFOW)
+    uint32_t cbData = pStream->u32CBL - u32LPIB;
+    AssertMsg(cbData, ("No CBL space left (%RU32/%RU32): %R[bdle]\n", pStream->u32CBL, u32LPIB, pBDLE));
+
+    /* Limit to the available free space of the current BDLE. */
+    cbData = RT_MIN(cbData, pBDLE->u32BufSize - pBDLE->State.u32BufOff);
+    AssertMsg(cbData, ("No BDLE space left (%RU32/%RU32): %R[bdle]\n", pBDLE->State.u32BufOff, pBDLE->u32BufSize, pBDLE));
+
+    /* Make sure we only transfer as many bytes as requested. */
+    cbData = RT_MIN(cbData, cbMax);
+
+    if (pBDLE->State.cbBelowFIFOW)
+    {
+        /* Are we not going to reach (or exceed) the FIFO watermark yet with the data to copy?
+         * No need to read data from DMA then. */
+        if (cbData > pBDLE->State.cbBelowFIFOW)
         {
-            /* Are we not going to reach (or exceed) the FIFO watermark yet with the data to copy?
-             * No need to read data from DMA then. */
-            if (cbFree > pBDLE->State.cbBelowFIFOW)
-            {
-                /* Subtract the amount of bytes that still would fit in the stream's FIFO
-                 * and therefore do not need to be processed by DMA. */
-                cbFree -= pBDLE->State.cbBelowFIFOW;
-            }
+            /* Subtract the amount of bytes that still would fit in the stream's FIFO
+             * and therefore do not need to be processed by DMA. */
+            cbData -= pBDLE->State.cbBelowFIFOW;
         }
     }
 
-    LogFlowFunc(("[SD%RU8]: CBL=%RU32, LPIB=%RU32, FIFOS=%RU16, cbFree=%RU32, %R[bdle]\n", pStream->u8SD,
-                 pStream->u32CBL, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), pStream->u16FIFOS, cbFree, pBDLE));
-    return cbFree;
+    AssertMsg((cbData % 2 == 0), ("Transfer size invalid: %RU32\n", cbData));
+
+    Log3Func(("[SD%RU8]: CBL=%RU32, LPIB=%RU32, FIFOS=%RU16, cbData=%RU32, %R[bdle]\n", pStream->u8SD,
+              pStream->u32CBL, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), pStream->u16FIFOS,
+              cbData, pBDLE));
+
+    return cbData;
 }
 
@@ -3287 +3267 @@
     if (!cbData || !cbProcessed)
         return;
+
+    Assert(pBDLE->u32BufSize >= cbProcessed);
 
     /* Fewer than cbBelowFIFOW bytes were copied.
@@ -3309 +3291 @@
     /* We always increment the position of DMA buffer counter because we're always reading
      * into an intermediate buffer. */
-    pBDLE->State.u32BufOff += cbData;
-    Assert(pBDLE->State.u32BufOff <= pBDLE->u32BufSize);
+    Assert(pBDLE->u32BufSize >= (pBDLE->State.u32BufOff + cbProcessed));
+    pBDLE->State.u32BufOff += cbProcessed;
 
     LogFlowFunc(("cbData=%RU32, cbProcessed=%RU32, %R[bdle]\n", cbData, cbProcessed, pBDLE));
@@ -3454 +3436 @@
     AssertPtrReturnVoid(pStream);
 
-    LogFlowFunc(("[SD%RU8]: cbInc=%RU32\n", pStream->u8SD, cbInc));
-
-    //Assert(cbInc <= pStream->u16FIFOS);
-
     if (!cbInc) /* Nothing to do? Bail out early. */
         return;
-
-    PHDABDLE pBDLE = &pStream->State.BDLE;
 
     /*
@@ -3468 +3444 @@
      * (ICH6 datasheet 18.2.38).
      */
+    PHDABDLE pBDLE = &pStream->State.BDLE;
     if (pBDLE->State.cbBelowFIFOW == 0) /* Did we hit (or exceed) the watermark? */
     {
-        uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
-
-        AssertMsg(((u32LPIB + cbInc) <= pStream->u32CBL),
-                  ("[SD%RU8] Increment (%RU32) exceeds CBL (%RU32): LPIB (%RU32)\n",
-                   pStream->u8SD, cbInc, pStream->u32CBL, u32LPIB));
-
-        u32LPIB = RT_MIN(u32LPIB + cbInc, pStream->u32CBL);
-
-        LogFlowFunc(("[SD%RU8]: LPIB: %RU32 -> %RU32, CBL=%RU32\n",
-                     pStream->u8SD,
-                     HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) + cbInc,
-                     pStream->u32CBL));
+        uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) + cbInc;
+
+        Log3Func(("[SD%RU8]: LPIB: %RU32 -> %RU32, CBL=%RU32\n",
+                  pStream->u8SD, HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), u32LPIB, pStream->u32CBL));
 
         hdaStreamUpdateLPIB(pThis, pStream, u32LPIB);
@@ -3487 +3456 @@
 }
 
-static bool hdaStreamTransferIsComplete(PHDASTATE pThis, PHDASTREAM pStream, bool *pfInterrupt)
-{
-    AssertPtrReturn(pThis,   true);
-    AssertPtrReturn(pStream, true);
+static bool hdaBDLEIsComplete(PHDABDLE pBDLE, bool *pfInterrupt)
+{
+    AssertPtrReturn(pBDLE, true);
 
     bool fInterrupt  = false;
     bool fIsComplete = false;
-
-    PHDABDLE       pBDLE   = &pStream->State.BDLE;
-#ifdef LOG_ENABLED
-    const uint32_t u32LPIB = HDA_STREAM_REG(pThis, LPIB, pStream->u8SD);
-#endif
 
     /* Check if the current BDLE entry is complete (full). */
@@ -3511 +3474 @@
            )
         {
-            LogFlowFunc(("[SD%RU8]: %R[bdle] => COMPLETE\n",  pStream->u8SD, pBDLE));
-
-            /*
-             * If the ICE (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_REG_FIELD_FLAG_MASK(SDCTL, ICE))
-                fInterrupt = true;
+            fInterrupt = true;
         }
 
@@ -3527 +3483 @@
         *pfInterrupt = fInterrupt;
 
-    LogFlowFunc(("[SD%RU8]: u32LPIB=%RU32, CBL=%RU32, fIsComplete=%RTbool, fInterrupt=%RTbool, %R[bdle]\n",
-                 pStream->u8SD, u32LPIB, pStream->u32CBL, fIsComplete, fInterrupt, pBDLE));
+    LogFlowFunc(("%R[bdle] fIsComplete=%RTbool, fInterrupt=%RTbool\n", pBDLE, fIsComplete, fInterrupt));
 
     return fIsComplete;
 }
 
+#if 0
 /**
  * hdaReadAudio - copies samples from audio backend to DMA.
@@ -3584 +3540 @@
 #ifdef HDA_DEBUG_DUMP_PCM_DATA
         RTFILE fh;
-        RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaReadAudio-hda.pcm",
+        RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaReadAudio.pcm",
                    RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
         RTFileWrite(fh, pBDLE->State.au8FIFO, cbRead, NULL);
@@ -3656 +3612 @@
 #ifdef HDA_DEBUG_DUMP_PCM_DATA
         RTFILE fh;
-        RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaWriteAudio-hda.pcm",
+        RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaWriteAudio.pcm",
                    RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
         RTFileWrite(fh, pvBuf, cbBuf, NULL);
@@ -3714 +3670 @@
             AssertRC(rc2);
 #endif
+
             /*
              * Write data to according mixer sinks.
@@ -3721 +3678 @@
             AssertRC(rc2);
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-            rc2 = AudioMixerSinkWrite(pThis->SinkCenterLFE,      AUDMIXOP_COPY, pvDataCenterLFE, cbDataCenterLFE,
+            rc2 = AudioMixerSinkWrite(pThis->SinkCenterLFE,      AUDMIXOP_COPY, pvDataCenterLFE, (uint32_t)cbDataCenterLFE,
                                       NULL /* pcbWritten */);
             AssertRC(rc2);
-            rc2 = AudioMixerSinkWrite(pThis->SinkRear,           AUDMIXOP_COPY, pvDataRear,      cbDataRear,
+            rc2 = AudioMixerSinkWrite(pThis->SinkRear,           AUDMIXOP_COPY, pvDataRear,      (uint32_t)cbDataRear,
                                       NULL /* pcbWritten */);
             AssertRC(rc2);
@@ -3745 +3702 @@
         else
         {
+            AssertFailed();
+
             Assert(pBDLE->State.u32BufOff + cbWritten <= pBDLE->u32BufSize);
             pBDLE->State.u32BufOff    += cbWritten;
@@ -3756 +3715 @@
     }
 
-    //Assert(cbWritten <= pStream->u16FIFOS);
+    Assert(cbWritten <= pStream->u16FIFOS);
 
     if (RT_SUCCESS(rc))
@@ -3769 +3728 @@
     return rc;
 }
+#endif
 
 /**
@@ -4129 +4089 @@
 static void hdaTimerMaybeStart(PHDASTATE pThis)
 {
-    if (pThis->cStreamsActive == 0) /* Only start the timer if there are no active streams. */
+    if (pThis->cStreamsActive == 0) /* Only start the timer if there at least is one active streams. */
         return;
 
@@ -4137 +4097 @@
     LogFlowFuncEnter();
 
-    LogFlowFunc(("Starting timer\n"));
+    LogRel2(("HDA: Starting transfers\n"));
 
     /* Set timer flag. */
@@ -4145 +4105 @@
     pThis->uTimerTS = TMTimerGet(pThis->pTimer);
 
-    /* Fire off timer. */
-    TMTimerSet(pThis->pTimer, TMTimerGet(pThis->pTimer) + pThis->cTimerTicks);
+    /* Start transfers. */
+    hdaDoTransfers(pThis);
 }
 
@@ -4157 +4117 @@
         return;
 
-    LogFlowFunc(("Stopping timer\n"));
+    LogRel2(("HDA: Stopping transfers\n"));
 
     /* Set timer flag. */
@@ -4163 +4123 @@
 }
 
-static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
-{
-    RT_NOREF(pDevIns);
-    PHDASTATE pThis = (PHDASTATE)pvUser;
-    Assert(pThis == PDMINS_2_DATA(pDevIns, PHDASTATE));
-    AssertPtr(pThis);
+static void hdaDoTransfers(PHDASTATE pThis)
+{
+    AssertPtrReturnVoid(pThis);
 
     STAM_PROFILE_START(&pThis->StatTimer, a);
 
-    uint64_t cTicksNow = TMTimerGet(pTimer);
-
-    LogFlowFuncEnter();
+    uint64_t cTicksNow = TMTimerGet(pThis->pTimer);
+
+    Log4Func(("Timer enter\n"));
 
     /* Update current time timestamp. */
@@ -4183 +4140 @@
     bool fKickTimer = false;
 
-    PHDASTREAM pStreamLineIn  = hdaGetStreamFromSink(pThis, &pThis->SinkLineIn);
+    PHDASTREAM pStreamLineIn  = hdaSinkGetStream(pThis, &pThis->SinkLineIn);
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    PHDASTREAM pStreamMicIn   = hdaGetStreamFromSink(pThis, &pThis->SinkMicIn);
-#endif
-    PHDASTREAM pStreamFront   = hdaGetStreamFromSink(pThis, &pThis->SinkFront);
+    PHDASTREAM pStreamMicIn   = hdaSinkGetStream(pThis, &pThis->SinkMicIn);
+#endif
+    PHDASTREAM pStreamFront   = hdaSinkGetStream(pThis, &pThis->SinkFront);
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
     /** @todo See note below. */
 #endif
 
-    uint32_t cbToProcess;
-    int rc = AudioMixerSinkUpdate(pThis->SinkLineIn.pMixSink);
-    if (RT_SUCCESS(rc))
-    {
-        cbToProcess = AudioMixerSinkGetReadable(pThis->SinkLineIn.pMixSink);
-        if (cbToProcess)
-        {
-            rc = hdaTransfer(pThis, pStreamLineIn, cbToProcess, NULL /* pcbProcessed */);
-            fKickTimer |= RT_SUCCESS(rc);
-        }
-    }
-
+    hdaStreamUpdate(pThis, pStreamLineIn);
 #ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
-    rc = AudioMixerSinkUpdate(pThis->SinkMicIn.pMixSink);
-    if (RT_SUCCESS(rc))
-    {
-        cbToProcess = AudioMixerSinkGetReadable(pThis->SinkMicIn.pMixSink);
-        if (cbToProcess)
-        {
-            rc = hdaTransfer(pThis, pStreamMicIn, cbToProcess, NULL /* pcbProcessed */);
-            fKickTimer |= RT_SUCCESS(rc);
-        }
-    }
-#endif
+    hdaStreamUpdate(pThis, pStreamMicIn);
+#endif
+    hdaStreamUpdate(pThis, pStreamFront);
+
 
 #ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
-    rc = AudioMixerSinkUpdate(pThis->SinkCenterLFE.pMixSink);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
-
-    rc = AudioMixerSinkUpdate(pThis->SinkRear.pMixSink);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
-    /** @todo Check for stream interleaving and only call hdaTransfer() if required! */
+    rc2 = AudioMixerSinkUpdate(pThis->SinkCenterLFE.pMixSink);
+    AssertRC(rc2);
+
+    rc2 = AudioMixerSinkUpdate(pThis->SinkRear.pMixSink);
+    AssertRC(rc2);
+    /** @todo Check for stream interleaving and only call hdaStreamDoDMA() if required! */
 
     /*
@@ -4237 +4170 @@
      */
 #endif
-    rc = AudioMixerSinkUpdate(pThis->SinkFront.pMixSink);
-    if (RT_SUCCESS(rc))
-    {
-        cbToProcess = AudioMixerSinkGetWritable(pThis->SinkFront.pMixSink);
-        if (cbToProcess)
-        {
-            rc = hdaTransfer(pThis, pStreamFront, cbToProcess, NULL /* pcbProcessed */);
-            fKickTimer |= RT_SUCCESS(rc);
-        }
-    }
+
+    /* Do we need to kick the timer again? */
+    if (   AudioMixerSinkIsActive(pThis->SinkFront.pMixSink)
+#ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
+        || AudioMixerSinkIsActive(pThis->SinkCenterLFE.pMixSink)
+        || AudioMixerSinkIsActive(pThis->SinkRear.pMixSink)
+#endif
+        || AudioMixerSinkIsActive(pThis->SinkLineIn.pMixSink)
+#ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
+        || AudioMixerSinkIsActive(pThis->SinkMicIn.pMixSink)
+#endif
+        )
+    {
+        fKickTimer = true;
+    }
+
+    pThis->uTimerMS = RTTimeMilliTS();
 
     if (   ASMAtomicReadBool(&pThis->fTimerActive)
@@ -4257 +4197 @@
     }
 
-    LogFlowFuncLeave();
-
     STAM_PROFILE_STOP(&pThis->StatTimer, a);
+}
+
+static DECLCALLBACK(void) hdaTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
+{
+    RT_NOREF(pDevIns, pTimer);
+
+    PHDASTATE pThis = (PHDASTATE)pvUser;
+    Assert(pThis == PDMINS_2_DATA(pDevIns, PHDASTATE));
+    AssertPtr(pThis);
+
+    hdaDoTransfers(pThis);
 }
 
@@ -4278 +4227 @@
     AssertReturn(cbUser == sizeof(PDMAUDIOCBDATA_DATA_INPUT), VERR_INVALID_PARAMETER);
 
-    return hdaTransfer(pCtx->pThis, PI_INDEX, UINT32_MAX, &pData->cbOutRead);
+    return hdaStreamDoDMA(pCtx->pThis, PI_INDEX, UINT32_MAX, &pData->cbOutRead);
 }
 
@@ -4297 +4246 @@
     PHDASTATE pThis = pCtx->pThis;
 
-    int rc = hdaTransfer(pCtx->pThis, PO_INDEX, UINT32_MAX, &pData->cbOutWritten);
+    int rc = hdaStreamDoDMA(pCtx->pThis, PO_INDEX, UINT32_MAX, &pData->cbOutWritten);
     if (   RT_SUCCESS(rc)
         && pData->cbOutWritten)
@@ -4312 +4261 @@
 #endif /* VBOX_WITH_AUDIO_HDA_CALLBACKS */
 
-static int hdaTransfer(PHDASTATE pThis, PHDASTREAM pStream, uint32_t cbToProcess, uint32_t *pcbProcessed)
-{
-    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
-    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+#ifdef DEBUG_andy
+# define HDA_DEBUG_DMA
+#endif
+
+/**
+ * Does a single DMA transfer for a specific HDA stream (SDI/SDO).
+ * This either can be a read or write operation, depending on the HDA stream.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               HDA state.
+ * @param   pStream             HDA stream to do the DMA transfer for.
+ * @param   pvBuf               Pointer to buffer data to write data to / read data from.
+ * @param   cbBuf               Size of buffer (in bytes).
+ * @param   cbToProcess         Size (in bytes) to transfer (read/write).
+ * @param   pcbProcessed        Size (in bytes) transferred (read/written). Optional.
+ */
+static int hdaStreamDoDMA(PHDASTATE pThis, PHDASTREAM pStream, void *pvBuf, uint32_t cbBuf,
+                          uint32_t cbToProcess, uint32_t *pcbProcessed)
+{
+    AssertPtrReturn(pThis,             VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream,           VERR_INVALID_POINTER);
+    AssertPtrReturn(pvBuf,             VERR_INVALID_POINTER);
+    AssertReturn(cbBuf >= cbToProcess, VERR_INVALID_PARAMETER);
     /* pcbProcessed is optional. */
 
     if (ASMAtomicReadBool(&pThis->fInReset)) /* HDA controller in reset mode? Bail out. */
     {
-        LogFlowFunc(("HDA in reset mode, skipping\n"));
-
         if (pcbProcessed)
             *pcbProcessed = 0;
@@ -4328 +4294 @@
 
     bool fProceed = true;
-    int rc = RTCritSectEnter(&pStream->State.CritSect);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    Log3Func(("[SD%RU8] fActive=%RTbool, cbToProcess=%RU32\n", pStream->u8SD, pStream->State.fActive, cbToProcess));
-
-    /* Stop request received? */
-    if (   !pStream->State.fActive
-        || pStream->State.fDoStop)
-    {
-        pStream->State.fActive = false;
-
-        rc = RTSemEventSignal(pStream->State.hStateChangedEvent);
-        AssertRC(rc);
-
+
+    Log3Func(("[SD%RU8] %R[sdsts] cbToProcess=%RU32\n",
+              pStream->u8SD, HDA_STREAM_REG(pThis, STS, pStream->u8SD), cbToProcess));
+
+    /* Is the stream not in a running state currently? */
+    if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
         fProceed = false;
-    }
-    /* Is the stream not in a running state currently? */
-    else if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
+    /* Is the BCIS (Buffer Completion Interrupt Status) flag set? Then we have to wait and skip. */
+    else if ((HDA_STREAM_REG(pThis, STS, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
         fProceed = false;
-    /* Nothing to process? */
-    else if (!cbToProcess)
-        fProceed = false;
-
-    if ((HDA_STREAM_REG(pThis, STS, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS)))
-    {
-        Log3Func(("[SD%RU8]: BCIS set\n", pStream->u8SD));
-        fProceed = false;
-    }
 
     if (!fProceed)
     {
-        Log3Func(("[SD%RU8]: Skipping\n", pStream->u8SD));
-
-        rc = RTCritSectLeave(&pStream->State.CritSect);
-        AssertRC(rc);
-
+#ifdef HDA_DEBUG_DMA
+        Log3Func(("DMA: Skip\n"));
+#endif
         if (pcbProcessed)
             *pcbProcessed = 0;
         return VINF_SUCCESS;
     }
+
+    int rc = VINF_SUCCESS;
+
+#ifdef HDA_DEBUG_DMA
+    Log3Func(("DMA: Start\n"));
+#endif
 
     /* Sanity checks. */
@@ -4379 +4330 @@
     Assert(HDA_STREAM_REG(pThis, LPIB, pStream->u8SD) <= pStream->u32CBL);
 
-    bool fInterrupt = false;
-
-#ifdef DEBUG_andy
-//# define DEBUG_SIMPLE
-#endif
-
-#ifdef DEBUG_SIMPLE
-    uint8_t u8FIFO[_16K+1];
-    size_t u8FIFOff = 0;
-#endif
-
-    uint32_t cbLeft           = cbToProcess;
+    bool fSendInterrupt = false;
+
+    /* Only do one FIFO size at a time. */
+    uint32_t cbLeft           = RT_MIN(pStream->u16FIFOS, RT_MIN(cbToProcess, cbBuf));
     uint32_t cbTotal          = 0;
     uint32_t cbChunk          = 0;
     uint32_t cbChunkProcessed = 0;
 
-    /* Set the FIFORDY bit on the stream while doing the transfer. */
-    HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
-
-    while (cbLeft)
-    {
-        /* Do we need to fetch the next Buffer Descriptor Entry (BDLE)? */
-        if (hdaStreamNeedsNextBDLE(pThis, pStream))
-        {
-            rc = hdaStreamGetNextBDLE(pThis, pStream);
-            if (RT_FAILURE(rc))
-                break;
-        }
-
+#ifdef HDA_DEBUG_DMA
+    LogFunc(("DMA: cbToProcess=%RU32, cbLeft=%RU32\n", cbToProcess, cbLeft));
+#endif
+
+    /* Get the maximum number of BDL entries. */
+    uint16_t cBDLE = pStream->u16LVI + 1;
+
+    while (   cbLeft
+           && cBDLE--)
+    {
         cbChunk          = hdaStreamGetTransferSize(pThis, pStream, cbLeft);
         cbChunkProcessed = 0;
 
-        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_IN)
-            rc = hdaReadAudio(pThis, pStream, cbChunk, &cbChunkProcessed);
-        else
+        PHDABDLE pBDLE = &pStream->State.BDLE;
+
+        if (cbChunk)
         {
-#ifndef DEBUG_SIMPLE
-            rc = hdaWriteAudio(pThis, pStream, cbChunk, &cbChunkProcessed);
-#else
-            void    *pvBuf = u8FIFO + u8FIFOff;
-            int32_t cbBuf  = cbChunk;
-
-            PHDABDLE pBDLE = &pStream->State.BDLE;
-
-            if (cbBuf)
-                rc = PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
-                                       pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
-                                       pvBuf, cbBuf);
-
-            cbChunkProcessed = cbChunk;
-
-            hdaBDLEUpdate(pBDLE, cbChunkProcessed, cbChunkProcessed);
-
-            u8FIFOff += cbChunkProcessed;
-            Assert((u8FIFOff & 1) == 0);
-            Assert(u8FIFOff <= sizeof(u8FIFO));
+            if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_OUT) /* Output (SDO). */
+            {
+                PDMDevHlpPhysRead(pThis->CTX_SUFF(pDevIns),
+                                  pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
+                                  (uint8_t *)pvBuf + cbTotal, cbChunk);
+            }
+            else /* Input (SDI). */
+            {
+                PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns),
+                                   pBDLE->u64BufAdr + pBDLE->State.u32BufOff,
+                                   (uint8_t *)pvBuf + cbTotal, cbChunk);
+            }
+
+#ifdef HDA_DEBUG_DUMP_PCM_DATA
+            RTFILE fh;
+            RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaDMA.pcm",
+                       RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
+            RTFileWrite(fh, (uint8_t *)pvBuf + cbTotal, cbChunk, NULL);
+            RTFileClose(fh);
 #endif
         }
 
-        if (RT_FAILURE(rc))
-            break;
-
-        hdaStreamTransferUpdate(pThis, pStream, cbChunkProcessed);
+        cbChunkProcessed = cbChunk;
+
+        hdaBDLEUpdate(pBDLE, cbChunkProcessed, cbChunkProcessed);
+
+        LogFunc(("DMA: Entry %RU32 Pos %RU32/%RU32 Chunk %RU32\n",
+                 pBDLE->State.u32BDLIndex, pBDLE->State.u32BufOff, pBDLE->u32BufSize, cbChunk));
 
         Assert(cbLeft >= cbChunkProcessed);
         cbLeft  -= cbChunkProcessed;
         cbTotal += cbChunkProcessed;
-
-        if (rc == VINF_EOF)
+        Assert(cbTotal <= cbToProcess);
+
+        hdaStreamTransferUpdate(pThis, pStream, cbChunkProcessed);
+
+#ifdef HDA_DEBUG_DMA
+        LogFunc(("DMA: LPIB %RU32 Pos %RU32 Left %RU32\n", HDA_STREAM_REG(pThis, LPIB, pStream->u8SD), cbTotal, cbLeft));
+#endif
+        bool fNeedsInterrupt = false;
+        bool fBDLEIsComplete = hdaBDLEIsComplete(pBDLE, &fNeedsInterrupt);
+
+        if (fNeedsInterrupt)
+            fSendInterrupt = true;
+
+        if (fBDLEIsComplete)
+        {
+            /* Do we need to fetch the next Buffer Descriptor Entry (BDLE)? */
+            if (hdaStreamNeedsNextBDLE(pThis, pStream))
+            {
+                bool fWrapAround;
+                rc = hdaStreamGetNextBDLE(pThis, pStream, &fWrapAround);
+                if (   RT_SUCCESS(rc)
+                    && fWrapAround)
+                {
+                    hdaStreamUpdateLPIB(pThis, pStream, 0);
+                }
+            }
+        }
+
+        if (RT_FAILURE(rc))
             break;
-
-        if (hdaStreamTransferIsComplete(pThis, pStream, &fInterrupt))
-            break;
-    }
-
-    /* Remove the FIFORDY bit again. */
-    HDA_STREAM_REG(pThis, STS, pStream->u8SD) &= ~HDA_REG_FIELD_FLAG_MASK(SDSTS, FIFORDY);
-
-    LogFlowFunc(("[SD%RU8]: %RU32 / %RU32, rc=%Rrc\n", pStream->u8SD, cbTotal, cbToProcess, rc));
-
-#ifdef DEBUG_SIMPLE
-# ifdef HDA_DEBUG_DUMP_PCM_DATA
-        RTFILE fh;
-        RTFileOpen(&fh, HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaWriteAudio.pcm",
-                   RTFILE_O_OPEN_CREATE | RTFILE_O_APPEND | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
-        RTFileWrite(fh, u8FIFO, u8FIFOff, NULL);
-        RTFileClose(fh);
-# endif
-
-     AudioMixerSinkWrite(pThis->SinkFront.pMixSink, AUDMIXOP_COPY, u8FIFO, u8FIFOff,
-                         NULL /* pcbWritten */);
-#endif /* DEBUG_SIMPLE */
-
-    if (fInterrupt)
-    {
+    }
+
+    Log3Func(("[SD%RU8]: cbLeft=%RU32, rc=%Rrc\n", pStream->u8SD, cbLeft, rc));
+
+    if (fSendInterrupt)
+    {
+#ifdef HDA_DEBUG_DMA
+        Log3Func(("DMA: Interrupt\n"));
+#endif
         /**
          * Set the BCIS (Buffer Completion Interrupt Status) flag as the
@@ -4485 +4437 @@
          */
         HDA_STREAM_REG(pThis, STS, pStream->u8SD) |= HDA_REG_FIELD_FLAG_MASK(SDSTS, BCIS);
-        Log3Func(("[SD%RU8]: BCIS: Set\n", pStream->u8SD));
+        Log3Func(("[SD%RU8]: BCIS set\n", pStream->u8SD));
 
         hdaProcessInterrupt(pThis);
@@ -4496 +4448 @@
     }
 
-    int rc2 = RTCritSectLeave(&pStream->State.CritSect);
-    if (RT_SUCCESS(rc))
-        rc = rc2;
+#ifdef HDA_DEBUG_DMA
+    Log3Func(("DMA: End\n"));
+#endif
+
+    return rc;
+}
+
+/**
+ * Updates a HDA stream according to its usage.
+ *
+ * For an SDO (output) stream this means reading DMA data from the device to
+ * the connected audio sink(s).
+ *
+ * For an SDI (input) stream this is reading audio data from the connected
+ * audio sink(s) and writing it as DMA data to the device.
+ *
+ * @returns IPRT status code.
+ * @param   pThis               HDA state.
+ * @param   pStream             HDA stream to update.
+ */
+static int hdaStreamUpdate(PHDASTATE pThis, PHDASTREAM pStream)
+{
+    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
+    AssertPtrReturn(pStream, VERR_INVALID_POINTER);
+
+    PHDAMIXERSINK pSink  = pStream->pMixSink;
+    if (!pSink)
+        return VINF_SUCCESS;
+
+    PAUDMIXSINK pMixSink = pSink->pMixSink;
+    AssertPtr(pSink);
+
+    if (AudioMixerSinkIsActive(pMixSink) == false)
+        return VINF_SUCCESS;
+
+    PRTCIRCBUF pCircBuf  = pStream->State.pCircBuf;
+    AssertPtr(pCircBuf);
+
+    void *pvSrc, *pvDst;
+    size_t cbSrc, cbDst;
+
+    int rc = VINF_SUCCESS;
+
+    uint32_t cbToProcess = _16K; /** @todo Tweak this. Later. */
+
+    while (cbToProcess >= pStream->u16FIFOS)
+    {
+        uint32_t cbProcessed;
+        int rc2;
+
+        if (hdaGetDirFromSD(pStream->u8SD) == PDMAUDIODIR_OUT) /* Output (SDO). */
+        {
+            if (RTCircBufUsed(pCircBuf) == 0)
+            {
+                Assert(pStream->u16FIFOS);
+                RTCircBufAcquireWriteBlock(pCircBuf, pStream->u16FIFOS, &pvDst, &cbDst);
+
+                /* Do one DMA transfer with FIFOS size at a time. */
+                rc2 = hdaStreamDoDMA(pThis, pStream, pvDst, cbDst, cbDst /* cbToProcess */, &cbProcessed);
+                AssertRC(rc2);
+
+                RTCircBufReleaseWriteBlock(pCircBuf, cbProcessed);
+
+                if (!cbProcessed)
+                    break;
+            }
+
+            if (RTCircBufUsed(pCircBuf))
+            {
+                RTCircBufAcquireReadBlock(pCircBuf, RTCircBufUsed(pCircBuf), &pvSrc, &cbSrc);
+                Assert(cbDst);
+
+                rc2 = AudioMixerSinkWrite(pSink->pMixSink, AUDMIXOP_COPY, pvSrc, cbSrc, &cbProcessed);
+                AssertRC(rc2);
+
+                RTCircBufReleaseReadBlock(pCircBuf, cbSrc);
+            }
+        }
+        else /* Input (SDI). */
+        {
+            Assert(pStream->u16FIFOS);
+            if (RTCircBufUsed(pCircBuf))
+            {
+                RTCircBufAcquireReadBlock(pCircBuf, pStream->u16FIFOS, &pvSrc, &cbSrc);
+
+                /* Do one DMA transfer with FIFOS size at a time. */
+                rc2 = hdaStreamDoDMA(pThis, pStream, pvSrc, cbSrc, cbSrc /* cbToProcess */, &cbProcessed);
+                AssertRC(rc2);
+
+                RTCircBufReleaseReadBlock(pCircBuf, cbSrc);
+
+                if (!cbProcessed)
+                    break;
+            }
+
+            if (RTCircBufUsed(pCircBuf) < pStream->u16FIFOS)
+            {
+                RTCircBufAcquireWriteBlock(pCircBuf, pStream->u16FIFOS, &pvDst, &cbDst);
+                Assert(cbDst);
+
+                rc2 = AudioMixerSinkRead(pSink->pMixSink, AUDMIXOP_COPY, pvDst, cbDst, &cbProcessed);
+                AssertRC(rc2);
+
+                RTCircBufReleaseWriteBlock(pCircBuf, cbDst);
+            }
+        }
+
+        rc2 = AudioMixerSinkUpdate(pSink->pMixSink);
+        AssertRC(rc2);
+
+        cbToProcess -= RT_MIN(cbToProcess, cbProcessed);
+    }
 
     return rc;
@@ -4986 +5047 @@
     rc = SSMR3GetU32(pSSM, &x.State.cbBelowFIFOW); /* cbUnderFifoW */   \
     AssertRCReturn(rc, rc);                                             \
-    rc = SSMR3GetMem(pSSM, &x.State.au8FIFO, sizeof(x.State.au8FIFO));  \
+    rc = SSMR3Skip(pSSM, sizeof(uint8_t) * 256);   /* FIFO */           \
     AssertRCReturn(rc, rc);                                             \
     rc = SSMR3Skip(pSSM, sizeof(uint32_t));        /* End marker */     \
@@ -5097 +5158 @@
                             rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.cbBelowFIFOW); /* cbBelowFIFOW */
                             AssertRC(rc);
-                            rc = SSMR3GetMem(pSSM,
-                                             &pStrm->State.BDLE.State.au8FIFO,
-                                             sizeof(pStrm->State.BDLE.State.au8FIFO));     /* au8FIFO */
+                            rc = SSMR3Skip(pSSM, sizeof(uint8_t) * 256);                   /* FIFO, deprecated */
                             AssertRC(rc);
                             rc = SSMR3GetU32(pSSM, &pStrm->State.BDLE.State.u32BufOff);    /* u32BufOff */
@@ -5109 +5168 @@
                         {
                             rc = SSMR3Skip(pSSM,   sizeof(uint32_t)      /* cbBelowFIFOW */
-                                                 + sizeof(uint8_t) * 256 /* au8FIFO */
+                                                 + sizeof(uint8_t) * 256 /* FIFO, deprecated */
                                                  + sizeof(uint32_t)      /* u32BufOff */
                                                  + sizeof(uint32_t));    /* End marker */
@@ -5508 +5567 @@
      */
     if (pThis->SinkFront.pMixSink)
-        AudioMixerSinkCtl(pThis->SinkFront.pMixSink,     AUDMIXSINKCMD_DISABLE);
+        AudioMixerSinkReset(pThis->SinkFront.pMixSink);
 # ifdef VBOX_WITH_AUDIO_HDA_MIC_IN
     if (pThis->SinkMicIn.pMixSink)
-        AudioMixerSinkCtl(pThis->SinkMicIn.pMixSink,     AUDMIXSINKCMD_DISABLE);
+        AudioMixerSinkReset(pThis->SinkMicIn.pMixSink);
 # endif
     if (pThis->SinkLineIn.pMixSink)
-        AudioMixerSinkCtl(pThis->SinkLineIn.pMixSink,    AUDMIXSINKCMD_DISABLE);
+        AudioMixerSinkReset(pThis->SinkLineIn.pMixSink);
 # ifdef VBOX_WITH_AUDIO_HDA_51_SURROUND
     if (pThis->SinkCenterLFE.pMixSink)
-        AudioMixerSinkCtl(pThis->SinkCenterLFE.pMixSink, AUDMIXSINKCMD_DISABLE);
+        AudioMixerSinkReset(pThis->SinkCenterLFE.pMixSink);
     if (pThis->SinkRear.pMixSink)
-        AudioMixerSinkCtl(pThis->SinkRear.pMixSink,      AUDMIXSINKCMD_DISABLE);
+        AudioMixerSinkReset(pThis->SinkRear.pMixSink);
 # endif
 
@@ -5837 +5896 @@
 #ifndef VBOX_WITH_AUDIO_HDA_CALLBACKS
     uint16_t uTimerHz;
-    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 200 /* Hz */);
+    rc = CFGMR3QueryU16Def(pCfg, "TimerHz", &uTimerHz, 100 /* Hz */);
     if (RT_FAILURE(rc))
         return PDMDEV_SET_ERROR(pDevIns, rc,
@@ -6263 +6322 @@
     if (RT_SUCCESS(rc))
     {
-        /* Start the emulation timer. */
+        /* Create the emulation timer. */
         rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, hdaTimer, pThis,
                                     TMTIMER_FLAGS_NO_CRIT_SECT, "DevHDA", &pThis->pTimer);
@@ -6273 +6332 @@
             pThis->uTimerTS    = TMTimerGet(pThis->pTimer);
             LogFunc(("Timer ticks=%RU64 (%RU16 Hz)\n", pThis->cTimerTicks, uTimerHz));
-
-            hdaTimerMaybeStart(pThis);
         }
     }
@@ -6322 +6379 @@
     }
 # endif
+
+#ifdef HDA_DEBUG_DUMP_PCM_DATA
+    RTFileDelete(HDA_DEBUG_DUMP_PCM_DATA_PATH "hdaDMA.pcm");
+#endif
 
     LogFlowFuncLeaveRC(rc);

trunk/src/VBox/Devices/testcase/tstDeviceStructSizeRC.cpp

@@ -1908 +1908 @@
     GEN_CHECK_OFF(HDABDLESTATE, u32BDLIndex);
     GEN_CHECK_OFF(HDABDLESTATE, cbBelowFIFOW);
-    GEN_CHECK_OFF(HDABDLESTATE, au8FIFO);
     GEN_CHECK_OFF(HDABDLESTATE, u32BufOff);
 
@@ -1919 +1918 @@
     GEN_CHECK_SIZE(HDASTREAMSTATE);
     GEN_CHECK_OFF(HDASTREAMSTATE, uCurBDLE);
+    GEN_CHECK_OFF(HDASTREAMSTATE, fInReset);
+    GEN_CHECK_OFF(HDASTREAMSTATE, CritSect);
+    GEN_CHECK_OFF(HDASTREAMSTATE, Mapping);
     GEN_CHECK_OFF(HDASTREAMSTATE, BDLE);
+    GEN_CHECK_OFF(HDASTREAMSTATE, pCircBuf);
 
     GEN_CHECK_SIZE(HDASTREAM);