Index: /trunk/src/VBox/Devices/Audio/DevCodec.cpp
===================================================================
--- /trunk/src/VBox/Devices/Audio/DevCodec.cpp	(revision 31155)
+++ /trunk/src/VBox/Devices/Audio/DevCodec.cpp	(revision 31156)
@@ -59,6 +59,4 @@
 #define CODEC_B_INDEX(cmd)      ((cmd) & CODEC_VERB_B_INDEX)
 
-/* RPM 5.3.1 */
-#define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
 
 #define STAC9220_NODE_COUNT 0x1C
@@ -101,4 +99,6 @@
 #define STAC9220_IS_CD_CMD(cmd) (CODEC_NID((cmd)) == 0x15)
 
+#define STAC9220_IS_VOLKNOB_CMD(cmd) (CODEC_NID((cmd)) == 0x15)
+
 /* STAC9220 6.2 & 6.12 */
 #define STAC9220_IS_RESERVED_CMD(cmd) ( \
@@ -123,5 +123,5 @@
     int rc;
     rc = codecUnimplemented(pState, cmd, pResp);
-    *pResp |= CODEC_RESPONSE_UNSOLICITED;
+    *pResp |= CODEC_RESPONSE_UNSOLICITED; /* ??? */
     return rc;
 }
@@ -218,4 +218,68 @@
     return VINF_SUCCESS;
 }
+
+static int codecGetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    if (STAC9220_IS_PORT_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
+    else if (STAC9220_IS_AFG_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].afg.u32F08_param;
+    else if (STAC9220_IS_VOLKNOB_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
+    else
+        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
+    return VINF_SUCCESS;
+}
+
+static int codecSetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    uint32_t *pu32Reg = NULL;
+    if (STAC9220_IS_PORT_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
+    else if (STAC9220_IS_AFG_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].afg.u32F08_param;
+    else if (STAC9220_IS_VOLKNOB_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
+    else
+        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
+    Assert(pu32Reg);
+    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
+    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
+    return VINF_SUCCESS;
+}
+
+static int codecGetPinSence(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    if (STAC9220_IS_PORT_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].port.u32F09_param;
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F09_param;
+    else
+        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
+    return VINF_SUCCESS;
+}
+static int codecSetPinSence(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    uint32_t *pu32Reg = NULL;
+    if (STAC9220_IS_PORT_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
+    Assert(pu32Reg);
+    if(!pu32Reg)
+        return VINF_SUCCESS;
+    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
+    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
+    return VINF_SUCCESS;
+}
+
 static int codecGetConnectionListEntry(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
 {
@@ -308,15 +372,56 @@
 }
 
-#if 0
 static int codecGetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
 {
     Assert((CODEC_CAD(cmd) == pState->id));
+    *pResp = 0;
     if (STAC9220_IS_AFG_CMD(cmd))
     {
         *pResp = pState->pNodes[CODEC_NID(cmd)].afg.u32F05_param;
     }
-    return VINF_SUCCESS;
-}
-#endif
+    else if (STAC9220_IS_DAC_CMD(cmd))
+    {
+        *pResp = pState->pNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    }
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+    {
+        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F05_param;
+    }
+    else if (STAC9220_IS_ADC_CMD(cmd))
+    {
+        *pResp = pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
+    }
+    return VINF_SUCCESS;
+}
+
+static int codecSetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
+{
+    Assert((CODEC_CAD(cmd) == pState->id));
+    uint32_t *pu32Reg = NULL;
+    *pResp = 0;
+    if (STAC9220_IS_AFG_CMD(cmd))
+    {
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].afg.u32F05_param;
+    }
+    else if (STAC9220_IS_DAC_CMD(cmd))
+    {
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    }
+    else if (STAC9220_IS_DIGPIN_CMD(cmd))
+    {
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F05_param;
+    }
+    else if (STAC9220_IS_ADC_CMD(cmd))
+    {
+        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
+    }
+    Assert((pu32Reg));
+    if (!pu32Reg)
+        return VINF_SUCCESS;
+    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
+    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
+    return VINF_SUCCESS;
+}
+
 static int codecGetStreamId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
 {
@@ -387,4 +492,5 @@
 {
     pNode->node.id = nodenum;
+    pNode->node.au32F00_param[0xF] = RT_BIT(3)|RT_BIT(0); /* Power statest Supported: D0-yes, D1, D2, D3-no*/
     switch (nodenum)
     {
@@ -401,14 +507,16 @@
             pNode->afg.node.name = "AFG";
             pNode->node.au32F00_param[4] = RT_MAKE_U32_FROM_U8(0x1a, 0x00, 0x02, 0x00);
-            pNode->node.au32F00_param[5] = RT_MAKE_U32_FROM_U8(0x1, 0x01, 0x00, 0x0);
+            pNode->node.au32F00_param[5] = RT_BIT(8)|RT_BIT(0);
             pNode->node.au32F00_param[8] = RT_MAKE_U32_FROM_U8(0x0d, 0x0d, 0x01, 0x0); /* Capabilities */
             //pNode->node.au32F00_param[0xa] = RT_BIT(19)|RT_BIT(18)|RT_BIT(17)|RT_BIT(10)|RT_BIT(9)|RT_BIT(8)|RT_BIT(7)|RT_BIT(6)|RT_BIT(5);
             pNode->node.au32F00_param[0xa] = RT_BIT(17)|RT_BIT(5);
+            pNode->node.au32F00_param[0xc] = (17 << 8)|RT_BIT(6)|RT_BIT(5)|RT_BIT(2)|RT_BIT(1)|RT_BIT(0);
             pNode->node.au32F00_param[0xb] = RT_BIT(0);
             pNode->node.au32F00_param[0xd] = RT_BIT(31)|(0x5 << 16)|(0xE)<<8;
             pNode->node.au32F00_param[0x12] = RT_BIT(31)|(0x2 << 16)|(0x7f << 8)|0x7f;
-            pNode->afg.u32F05_param = (0x2) << 4 | 0x2; /* PS-Act: 0x2, D2 */
-            pNode->afg.u32F20_param = 0x83847626; /*STAC9271X */
-            pNode->afg.u32F08_param = 0;
+            pNode->node.au32F00_param[0x11] = 0;
+            pNode->afg.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
+            pNode->afg.u32F20_param = 0x83847882;
+            pNode->afg.u32F08_param = RT_BIT(7);
             break;
         case 2:
@@ -433,4 +541,5 @@
             pNode->dac.node.au32F00_param[5] = (0x3 << 4) | 0x3;
             pNode->dac.u32F0c_param = 0;
+            pNode->dac.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
         break;
         case 6:
@@ -445,5 +554,5 @@
             pNode->adc.node.au32F00_param[0xE] = RT_BIT(0);
             pNode->adc.u32F03_param = RT_BIT(0);
-            pNode->adc.u32F05_param = (0x3 << 4) | 0x3;
+            pNode->adc.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
             pNode->adc.u32F06_param = 0;
             pNode->adc.node.au32F00_param[9] = RT_BIT(20)| (0xd << 16) |  RT_BIT(10) | RT_BIT(8) | RT_BIT(6)| RT_BIT(0);
@@ -464,7 +573,9 @@
         case 0xA:
             pNode->node.name = "PortA";
-            pNode->node.au32F00_param[0xC] = 0x173f;
+            pNode->node.au32F00_param[0xC] = 0x173d;
             *(uint32_t *)pNode->node.au8F02_param = 0x2;
-            pNode->port.u32F07_param = 0;
+            pNode->port.u32F07_param = RT_BIT(6);
+            pNode->port.u32F08_param = RT_BIT(7);
+            pNode->port.u32F09_param = RT_BIT(31)|RT_BIT(30); /* 39.2 kOm */
             pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x20, 0x40, 0x21, 0x02);
             goto port_init;
@@ -473,4 +584,5 @@
             pNode->node.au32F00_param[0xC] = 0x1737;
             *(uint32_t *)pNode->node.au8F02_param = 0x4;
+            pNode->port.u32F09_param = 0;
             pNode->port.u32F07_param = RT_BIT(5);
             pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x11, 0x60, 0x11, 0x01);
@@ -480,4 +592,5 @@
             *(uint32_t *)pNode->node.au8F02_param = 0x3;
             pNode->node.au32F00_param[0xC] = 0x1737;
+            pNode->port.u32F09_param = 0;
             pNode->port.u32F07_param = RT_BIT(5);
             pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x10, 0x40, 0x11, 0x01);
@@ -485,8 +598,8 @@
         case 0xD:
             pNode->node.name = "PortD";
+            pNode->port.u32F09_param = 0;
             *(uint32_t *)pNode->node.au8F02_param = 0x2;
         port_init:
             pNode->port.u32F08_param = 0;
-            pNode->port.u32F09_param = 0x7fffffff;
             pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
             pNode->node.au32F00_param[0xE] = 0x1;
@@ -510,5 +623,5 @@
             pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x12, 0x60, 0x11, 0x01);
             pNode->node.au8F02_param[0] = 0x5;
-            pNode->port.u32F09_param = 0x7fffffff;
+            pNode->port.u32F09_param = 0;
         break;
         case 0x10:
@@ -526,5 +639,5 @@
             pNode->node.au32F00_param[9] = (4 << 20)|(3<<16)|RT_BIT(10)|RT_BIT(9)|RT_BIT(7)|RT_BIT(0);
             pNode->node.au32F00_param[0xC] = /* RT_BIT(16)|*/ RT_BIT(5)|RT_BIT(2);
-            pNode->digin.u32F05_param = (3 << 4)|0x3;
+            pNode->digin.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
             pNode->digin.u32F07_param = 0;
             pNode->digin.u32F08_param = 0;
@@ -606,4 +719,8 @@
     {0x000F0700, CODEC_VERB_8BIT_CMD , codecGetPinCtrl             },
     {0x00070700, CODEC_VERB_8BIT_CMD , codecSetPinCtrl             },
+    {0x000F0800, CODEC_VERB_8BIT_CMD , codecGetUnsolicitedEnabled  },
+    {0x00070800, CODEC_VERB_8BIT_CMD , codecSetUnsolicitedEnabled  },
+    {0x000F0900, CODEC_VERB_8BIT_CMD , codecGetPinSence            },
+    {0x00070900, CODEC_VERB_8BIT_CMD , codecSetPinSence            },
     {0x000F0200, CODEC_VERB_8BIT_CMD , codecGetConnectionListEntry },
     {0x000F0300, CODEC_VERB_8BIT_CMD , codecGetProcessingState     },
@@ -614,7 +731,6 @@
     {0x000F2000, CODEC_VERB_8BIT_CMD , codecGetSubId               },
     {0x0007FF00, CODEC_VERB_8BIT_CMD , codecReset                  },
-#if 0
-    {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState},
-#endif
+    {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState          },
+    {0x00070500, CODEC_VERB_8BIT_CMD , codecSetPowerState          },
 };
 
@@ -627,5 +743,5 @@
         || STAC9220_IS_RESERVED_CMD(cmd))
     {
-        *pfn = CODEC_VERBDATA(cmd) != 0 ? codecUnimplemented : codecBreak;
+        *pfn = codecUnimplemented;
         //** @todo r=michaln: There needs to be a counter to avoid log flooding (see e.g. DevRTC.cpp)
         LogRel(("HDAcodec: cmd %x was ignored\n", cmd));
Index: /trunk/src/VBox/Devices/Audio/DevCodec.h
===================================================================
--- /trunk/src/VBox/Devices/Audio/DevCodec.h	(revision 31155)
+++ /trunk/src/VBox/Devices/Audio/DevCodec.h	(revision 31156)
@@ -23,4 +23,7 @@
 typedef FNCODECVERBPROCESSOR *PFNCODECVERBPROCESSOR;
 typedef FNCODECVERBPROCESSOR **PPFNCODECVERBPROCESSOR;
+
+/* RPM 5.3.1 */
+#define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
 
 typedef struct CODECVERB
Index: /trunk/src/VBox/Devices/Audio/DevIchIntelHDA.cpp
===================================================================
--- /trunk/src/VBox/Devices/Audio/DevIchIntelHDA.cpp	(revision 31155)
+++ /trunk/src/VBox/Devices/Audio/DevIchIntelHDA.cpp	(revision 31156)
@@ -76,4 +76,5 @@
 #define ICH6_HDA_GCTL_RST_SHIFT (0)
 #define ICH6_HDA_GCTL_FSH_SHIFT (1)
+#define ICH6_HDA_GCTL_UR_SHIFT (8)
 #define GCTL(pState) (HDA_REG((pState), GCTL))
 
@@ -379,4 +380,5 @@
     bool        fInReset;
     CODECState  Codec;
+    uint8_t     u8Counter;
 } INTELHDLinkState;
 
@@ -660,5 +662,5 @@
                 else
                     prefix = "   ";
-                Log((" %s%016x", prefix, pState->pu64RirbBuf[i + j]));
+                Log((" %s%016lx", prefix, pState->pu64RirbBuf[i + j]));
             } while (++j < 8);
             Log(("\n"));
@@ -668,4 +670,17 @@
     return rc;
 }
+
+#if 0
+static int hdaUnsolictedResponse(INTELHDLinkState *pState, uint64_t pu64UnsolictedResponse)
+{
+    uint8_t rirbWp;
+    if (!HDA_REG_FLAG_VALUE(pState, GCTL, UR))
+    {
+        Log(("hda: unsolisited response %016lx is ignored\n"));
+        return VINF_SUCCESS;
+    }
+}
+#endif
+
 static int hdaCORBCmdProcess(INTELHDLinkState *pState)
 {
@@ -674,5 +689,4 @@
     uint8_t corbWp;
     uint8_t rirbWp;
-    uint8_t u8Counter = 0;
 
     PFNCODECVERBPROCESSOR pfn = (PFNCODECVERBPROCESSOR)NULL;
@@ -689,4 +703,5 @@
     {
         uint32_t cmd;
+        uint64_t resp;
         corbRp++;
         cmd = pState->pu32CorbBuf[corbRp];
@@ -696,9 +711,18 @@
         Assert(pfn);
         (rirbWp)++;
-        rc = pfn(&pState->Codec, cmd, &pState->pu64RirbBuf[rirbWp]);
+        rc = pfn(&pState->Codec, cmd, &resp);
         if (RT_FAILURE(rc))
             AssertRCReturn(rc, rc);
-        u8Counter++;
-        if (u8Counter == RINTCNT_N(pState))
+        Log(("hda: verb:%08x->%016lx\n", cmd, resp));
+        if (   (resp & CODEC_RESPONSE_UNSOLICITED)
+            && !HDA_REG_FLAG_VALUE(pState, GCTL, UR))
+        {
+            Log(("hda: unexpected unsolisited response.\n"));
+            pState->au32Regs[ICH6_HDA_REG_CORBRP] = corbRp;
+            return rc;
+        }
+        pState->pu64RirbBuf[rirbWp] = resp;
+        pState->u8Counter++;
+        if (pState->u8Counter == RINTCNT_N(pState))
             break;
     }
@@ -710,4 +734,5 @@
     {
         RIRBSTS((pState)) |= HDA_REG_FIELD_FLAG_MASK(RIRBSTS,RINTFL);
+        pState->u8Counter = 0;
         rc = hdaProcessInterrupt(pState);
     }
@@ -1166,4 +1191,5 @@
     return VINF_SUCCESS;
 }
+
 DECLCALLBACK(void) hdaTransfer(CODECState *pCodecState, ENMSOUNDSOURCE src, int avail)
 {
@@ -1501,8 +1527,10 @@
     pThis->dev.config[0x53] = 0x00; /* PM - disabled,  */
 
+#if 0
     pThis->dev.config[0x60] = 0x05;
     pThis->dev.config[0x61] = 0x70; /* next */
     pThis->dev.config[0x62] = 0x00;
     pThis->dev.config[0x63] = 0x80;
+#endif
 
     /*