VirtualBox

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


Ignore:
Timestamp:
Jul 9, 2021 12:47:21 PM (4 years ago)
Author:
vboxsync
Message:

DevHdaCodec: Reverted previous commit, committed too much. bugref:9890

Location:
trunk/src/VBox/Devices/Audio
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Audio/DevHdaCodec.cpp

    r90120 r90121  
    932932
    933933/**
    934  * @interface_method_impl{CODECVERB,pfn, Unimplemented}
    935  */
    936 static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    937 {
    938     RT_NOREF(pThis, pThisCC, uCmd);
    939     LogFlowFunc(("uCmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", uCmd,
    940                  CODEC_CAD(uCmd), CODEC_DIRECT(uCmd) ? 'N' : 'Y', CODEC_NID(uCmd), CODEC_VERBDATA(uCmd)));
    941     *puResp = 0;
    942     return VINF_SUCCESS;
    943 }
    944 
    945 
    946 /**
    947  * @interface_method_impl{CODECVERB,pfn, ???}
    948  */
    949 static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     934 * @interface_method_impl{CODECVERB, pfn, Unimplemented}
     935 */
     936static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     937{
     938    RT_NOREF(pThis, pThisCC, cmd);
     939    LogFlowFunc(("cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
     940                 CODEC_CAD(cmd), CODEC_DIRECT(cmd) ? 'N' : 'Y', CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
     941    *pResp = 0;
     942    return VINF_SUCCESS;
     943}
     944
     945
     946/**
     947 * @interface_method_impl{CODECVERB, pfn, ???}
     948 */
     949static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    950950{
    951951    int rc;
    952     rc = vrbProcUnimplemented(pThis, pThisCC, uCmd, puResp);
    953     *puResp |= CODEC_RESPONSE_UNSOLICITED;
     952    rc = vrbProcUnimplemented(pThis, pThisCC, cmd, pResp);
     953    *pResp |= CODEC_RESPONSE_UNSOLICITED;
    954954    return rc;
    955955}
    … …  
    958958
    959959/**
    960  * @interface_method_impl{CODECVERB,pfn, b--}
    961  */
    962 static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    963 {
    964     RT_NOREF(pThisCC);
    965     *puResp = 0;
     960 * @interface_method_impl{CODECVERB, pfn, b--}
     961 */
     962static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     963{
     964    RT_NOREF(pThisCC);
     965    *pResp = 0;
    966966
    967967    /* HDA spec 7.3.3.7 Note A */
    968968    /** @todo If index out of range response should be 0. */
    969     uint8_t u8Index = CODEC_GET_AMP_DIRECTION(uCmd) == AMPLIFIER_OUT ? 0 : CODEC_GET_AMP_INDEX(uCmd);
    970 
    971     PCODECNODE pNode = &pThis->aNodes[CODEC_NID(uCmd)];
    972     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    973         *puResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
    974                                      CODEC_GET_AMP_DIRECTION(uCmd),
    975                                      CODEC_GET_AMP_SIDE(uCmd),
    976                                      u8Index);
    977     else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    978         *puResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
    979                                      CODEC_GET_AMP_DIRECTION(uCmd),
    980                                      CODEC_GET_AMP_SIDE(uCmd),
    981                                      u8Index);
    982     else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(uCmd)))
    983         *puResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
    984                                      CODEC_GET_AMP_DIRECTION(uCmd),
    985                                      CODEC_GET_AMP_SIDE(uCmd),
    986                                      u8Index);
    987     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    988         *puResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
    989                                      CODEC_GET_AMP_DIRECTION(uCmd),
    990                                      CODEC_GET_AMP_SIDE(uCmd),
    991                                      u8Index);
    992     else if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    993         *puResp = AMPLIFIER_REGISTER(pNode->port.B_params,
    994                                      CODEC_GET_AMP_DIRECTION(uCmd),
    995                                      CODEC_GET_AMP_SIDE(uCmd),
    996                                      u8Index);
    997     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    998         *puResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
    999                                      CODEC_GET_AMP_DIRECTION(uCmd),
    1000                                      CODEC_GET_AMP_SIDE(uCmd),
    1001                                      u8Index);
    1002     else
    1003         LogRel2(("HDA: Warning: Unhandled get amplifier command: 0x%x (NID=0x%x [%RU8])\n", uCmd, CODEC_NID(uCmd), CODEC_NID(uCmd)));
    1004 
    1005     return VINF_SUCCESS;
    1006 }
    1007 
    1008 
    1009 /**
    1010  * @interface_method_impl{CODECVERB,pfn, ???}
    1011  */
    1012 static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1013 {
    1014     RT_NOREF(pThisCC);
    1015     Assert((uCmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
    1016     if ((uCmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
    1017     {
    1018         *puResp = 0;
    1019 
    1020         LogFlowFunc(("invalid F00 parameter %d\n", (uCmd & CODEC_VERB_8BIT_DATA)));
     969    uint8_t u8Index = CODEC_GET_AMP_DIRECTION(cmd) == AMPLIFIER_OUT ? 0 : CODEC_GET_AMP_INDEX(cmd);
     970
     971    PCODECNODE pNode = &pThis->aNodes[CODEC_NID(cmd)];
     972    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     973        *pResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
     974                                    CODEC_GET_AMP_DIRECTION(cmd),
     975                                    CODEC_GET_AMP_SIDE(cmd),
     976                                    u8Index);
     977    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     978        *pResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
     979                                    CODEC_GET_AMP_DIRECTION(cmd),
     980                                    CODEC_GET_AMP_SIDE(cmd),
     981                                    u8Index);
     982    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
     983        *pResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
     984                                    CODEC_GET_AMP_DIRECTION(cmd),
     985                                    CODEC_GET_AMP_SIDE(cmd),
     986                                    u8Index);
     987    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     988        *pResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
     989                                    CODEC_GET_AMP_DIRECTION(cmd),
     990                                    CODEC_GET_AMP_SIDE(cmd),
     991                                    u8Index);
     992    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     993        *pResp = AMPLIFIER_REGISTER(pNode->port.B_params,
     994                                    CODEC_GET_AMP_DIRECTION(cmd),
     995                                    CODEC_GET_AMP_SIDE(cmd),
     996                                    u8Index);
     997    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     998        *pResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
     999                                    CODEC_GET_AMP_DIRECTION(cmd),
     1000                                    CODEC_GET_AMP_SIDE(cmd),
     1001                                    u8Index);
     1002    else
     1003        LogRel2(("HDA: Warning: Unhandled get amplifier command: 0x%x (NID=0x%x [%RU8])\n", cmd, CODEC_NID(cmd), CODEC_NID(cmd)));
     1004
     1005    return VINF_SUCCESS;
     1006}
     1007
     1008
     1009/**
     1010 * @interface_method_impl{CODECVERB, pfn, ???}
     1011 */
     1012static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1013{
     1014    RT_NOREF(pThisCC);
     1015    Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
     1016    if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
     1017    {
     1018        *pResp = 0;
     1019
     1020        LogFlowFunc(("invalid F00 parameter %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
    10211021        return VINF_SUCCESS;
    10221022    }
    10231023
    1024     *puResp = pThis->aNodes[CODEC_NID(uCmd)].node.au32F00_param[uCmd & CODEC_VERB_8BIT_DATA];
    1025     return VINF_SUCCESS;
    1026 }
    1027 
    1028 
    1029 /**
    1030  * @interface_method_impl{CODECVERB,pfn, f01}
    1031  */
    1032 static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1033 {
    1034     RT_NOREF(pThisCC);
    1035     *puResp = 0;
    1036 
    1037     if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(uCmd)))
    1038         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adcmux.u32F01_param;
    1039     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1040         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digout.u32F01_param;
    1041     else if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1042         *puResp = pThis->aNodes[CODEC_NID(uCmd)].port.u32F01_param;
    1043     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1044         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adc.u32F01_param;
    1045     else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    1046         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adcvol.u32F01_param;
    1047     else
    1048         LogRel2(("HDA: Warning: Unhandled get connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1049 
    1050     return VINF_SUCCESS;
    1051 }
    1052 
    1053 
    1054 /**
    1055  * @interface_method_impl{CODECVERB,pfn, 701}
    1056  */
    1057 static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1058 {
    1059     RT_NOREF(pThisCC);
    1060     *puResp = 0;
     1024    *pResp = pThis->aNodes[CODEC_NID(cmd)].node.au32F00_param[cmd & CODEC_VERB_8BIT_DATA];
     1025    return VINF_SUCCESS;
     1026}
     1027
     1028
     1029/**
     1030 * @interface_method_impl{CODECVERB, pfn, f01}
     1031 */
     1032static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1033{
     1034    RT_NOREF(pThisCC);
     1035    *pResp = 0;
     1036
     1037    if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
     1038        *pResp = pThis->aNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
     1039    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1040        *pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F01_param;
     1041    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1042        *pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F01_param;
     1043    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1044        *pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F01_param;
     1045    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     1046        *pResp = pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
     1047    else
     1048        LogRel2(("HDA: Warning: Unhandled get connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1049
     1050    return VINF_SUCCESS;
     1051}
     1052
     1053
     1054/**
     1055 * @interface_method_impl{CODECVERB, pfn, 701}
     1056 */
     1057static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1058{
     1059    RT_NOREF(pThisCC);
     1060    *pResp = 0;
    10611061
    10621062    uint32_t *pu32Reg = NULL;
    1063     if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(uCmd)))
    1064         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adcmux.u32F01_param;
    1065     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1066         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digout.u32F01_param;
    1067     else if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1068         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].port.u32F01_param;
    1069     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1070         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adc.u32F01_param;
    1071     else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    1072         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adcvol.u32F01_param;
    1073     else
    1074         LogRel2(("HDA: Warning: Unhandled set connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1063    if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
     1064        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
     1065    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1066        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F01_param;
     1067    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1068        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F01_param;
     1069    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1070        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F01_param;
     1071    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     1072        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
     1073    else
     1074        LogRel2(("HDA: Warning: Unhandled set connection select control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    10751075
    10761076    if (pu32Reg)
    1077         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1078 
    1079     return VINF_SUCCESS;
    1080 }
    1081 
    1082 
    1083 /**
    1084  * @interface_method_impl{CODECVERB,pfn, f07}
    1085  */
    1086 static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1087 {
    1088     RT_NOREF(pThisCC);
    1089     *puResp = 0;
    1090 
    1091     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1092         *puResp = pThis->aNodes[CODEC_NID(uCmd)].port.u32F07_param;
    1093     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1094         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digout.u32F07_param;
    1095     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1096         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F07_param;
    1097     else if (hdaCodecIsCdNode(pThis, CODEC_NID(uCmd)))
    1098         *puResp = pThis->aNodes[CODEC_NID(uCmd)].cdnode.u32F07_param;
    1099     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    1100         *puResp = pThis->aNodes[CODEC_NID(uCmd)].pcbeep.u32F07_param;
    1101     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1102         *puResp = pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F07_param;
    1103     else
    1104         LogRel2(("HDA: Warning: Unhandled get pin control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1105 
    1106     return VINF_SUCCESS;
    1107 }
    1108 
    1109 
    1110 /**
    1111  * @interface_method_impl{CODECVERB,pfn, 707}
    1112  */
    1113 static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1114 {
    1115     RT_NOREF(pThisCC);
    1116     *puResp = 0;
     1077        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1078
     1079    return VINF_SUCCESS;
     1080}
     1081
     1082
     1083/**
     1084 * @interface_method_impl{CODECVERB, pfn, f07}
     1085 */
     1086static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1087{
     1088    RT_NOREF(pThisCC);
     1089    *pResp = 0;
     1090
     1091    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1092        *pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F07_param;
     1093    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1094        *pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F07_param;
     1095    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1096        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F07_param;
     1097    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
     1098        *pResp = pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
     1099    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     1100        *pResp = pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
     1101    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1102        *pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F07_param;
     1103    else
     1104        LogRel2(("HDA: Warning: Unhandled get pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1105
     1106    return VINF_SUCCESS;
     1107}
     1108
     1109
     1110/**
     1111 * @interface_method_impl{CODECVERB, pfn, 707}
     1112 */
     1113static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1114{
     1115    RT_NOREF(pThisCC);
     1116    *pResp = 0;
    11171117
    11181118    uint32_t *pu32Reg = NULL;
    1119     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1120         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].port.u32F07_param;
    1121     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1122         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F07_param;
    1123     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1124         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digout.u32F07_param;
    1125     else if (hdaCodecIsCdNode(pThis, CODEC_NID(uCmd)))
    1126         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].cdnode.u32F07_param;
    1127     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    1128         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].pcbeep.u32F07_param;
    1129     else if (   hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd))
    1130              && CODEC_NID(uCmd) == 0x1b)
    1131         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F07_param;
    1132     else
    1133         LogRel2(("HDA: Warning: Unhandled set pin control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1119    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1120        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F07_param;
     1121    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1122        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F07_param;
     1123    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1124        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F07_param;
     1125    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
     1126        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
     1127    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     1128        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
     1129    else if (   hdaCodecIsReservedNode(pThis, CODEC_NID(cmd))
     1130             && CODEC_NID(cmd) == 0x1b)
     1131        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F07_param;
     1132    else
     1133        LogRel2(("HDA: Warning: Unhandled set pin control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    11341134
    11351135    if (pu32Reg)
    1136         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1137 
    1138     return VINF_SUCCESS;
    1139 }
    1140 
    1141 
    1142 /**
    1143  * @interface_method_impl{CODECVERB,pfn, f08}
    1144  */
    1145 static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1146 {
    1147     RT_NOREF(pThisCC);
    1148     *puResp = 0;
    1149 
    1150     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1151         *puResp = pThis->aNodes[CODEC_NID(uCmd)].port.u32F08_param;
    1152     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1153         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F08_param;
    1154     else if ((uCmd) == STAC9220_NID_AFG)
    1155         *puResp = pThis->aNodes[CODEC_NID(uCmd)].afg.u32F08_param;
    1156     else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(uCmd)))
    1157         *puResp = pThis->aNodes[CODEC_NID(uCmd)].volumeKnob.u32F08_param;
    1158     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1159         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digout.u32F08_param;
    1160     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1161         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F08_param;
    1162     else
    1163         LogRel2(("HDA: Warning: Unhandled get unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1164 
    1165     return VINF_SUCCESS;
    1166 }
    1167 
    1168 
    1169 /**
    1170  * @interface_method_impl{CODECVERB,pfn, 708}
    1171  */
    1172 static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1173 {
    1174     RT_NOREF(pThisCC);
    1175     *puResp = 0;
     1136        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1137
     1138    return VINF_SUCCESS;
     1139}
     1140
     1141
     1142/**
     1143 * @interface_method_impl{CODECVERB, pfn, f08}
     1144 */
     1145static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1146{
     1147    RT_NOREF(pThisCC);
     1148    *pResp = 0;
     1149
     1150    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1151        *pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F08_param;
     1152    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1153        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
     1154    else if ((cmd) == STAC9220_NID_AFG)
     1155        *pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F08_param;
     1156    else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
     1157        *pResp = pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     1158    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1159        *pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F08_param;
     1160    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1161        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
     1162    else
     1163        LogRel2(("HDA: Warning: Unhandled get unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1164
     1165    return VINF_SUCCESS;
     1166}
     1167
     1168
     1169/**
     1170 * @interface_method_impl{CODECVERB, pfn, 708}
     1171 */
     1172static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1173{
     1174    RT_NOREF(pThisCC);
     1175    *pResp = 0;
    11761176
    11771177    uint32_t *pu32Reg = NULL;
    1178     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1179         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].port.u32F08_param;
    1180     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1181         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F08_param;
    1182     else if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1183         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].afg.u32F08_param;
    1184     else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(uCmd)))
    1185         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].volumeKnob.u32F08_param;
    1186     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1187         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F08_param;
    1188     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1189         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digout.u32F08_param;
    1190     else
    1191         LogRel2(("HDA: Warning: Unhandled set unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1178    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1179        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F08_param;
     1180    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1181        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
     1182    else if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1183        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F08_param;
     1184    else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
     1185        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     1186    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1187        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F08_param;
     1188    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1189        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F08_param;
     1190    else
     1191        LogRel2(("HDA: Warning: Unhandled set unsolicited enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    11921192
    11931193    if (pu32Reg)
    1194         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1195 
    1196     return VINF_SUCCESS;
    1197 }
    1198 
    1199 
    1200 /**
    1201  * @interface_method_impl{CODECVERB,pfn, f09}
    1202  */
    1203 static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1204 {
    1205     RT_NOREF(pThisCC);
    1206     *puResp = 0;
    1207 
    1208     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1209         *puResp = pThis->aNodes[CODEC_NID(uCmd)].port.u32F09_param;
    1210     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1211         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F09_param;
     1194        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1195
     1196    return VINF_SUCCESS;
     1197}
     1198
     1199
     1200/**
     1201 * @interface_method_impl{CODECVERB, pfn, f09}
     1202 */
     1203static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1204{
     1205    RT_NOREF(pThisCC);
     1206    *pResp = 0;
     1207
     1208    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1209        *pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F09_param;
     1210    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1211        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F09_param;
    12121212    else
    12131213    {
    12141214        AssertFailed();
    1215         LogRel2(("HDA: Warning: Unhandled get pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1216     }
    1217 
    1218     return VINF_SUCCESS;
    1219 }
    1220 
    1221 
    1222 /**
    1223  * @interface_method_impl{CODECVERB,pfn, 709}
    1224  */
    1225 static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1226 {
    1227     RT_NOREF(pThisCC);
    1228     *puResp = 0;
     1215        LogRel2(("HDA: Warning: Unhandled get pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1216    }
     1217
     1218    return VINF_SUCCESS;
     1219}
     1220
     1221
     1222/**
     1223 * @interface_method_impl{CODECVERB, pfn, 709}
     1224 */
     1225static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1226{
     1227    RT_NOREF(pThisCC);
     1228    *pResp = 0;
    12291229
    12301230    uint32_t *pu32Reg = NULL;
    1231     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1232         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].port.u32F09_param;
    1233     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1234         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F09_param;
    1235     else
    1236         LogRel2(("HDA: Warning: Unhandled set pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1231    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1232        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F09_param;
     1233    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1234        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F09_param;
     1235    else
     1236        LogRel2(("HDA: Warning: Unhandled set pin sense command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    12371237
    12381238    if (pu32Reg)
    1239         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1240 
    1241     return VINF_SUCCESS;
    1242 }
    1243 
    1244 
    1245 /**
    1246  * @interface_method_impl{CODECVERB,pfn, ???}
    1247  */
    1248 static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1249 {
    1250     RT_NOREF(pThisCC);
    1251     *puResp = 0;
    1252 
    1253     Assert((uCmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F02_PARAM_LENGTH);
    1254     if ((uCmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F02_PARAM_LENGTH)
    1255     {
    1256         LogFlowFunc(("access to invalid F02 index %d\n", (uCmd & CODEC_VERB_8BIT_DATA)));
     1239        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1240
     1241    return VINF_SUCCESS;
     1242}
     1243
     1244
     1245/**
     1246 * @interface_method_impl{CODECVERB, pfn, ???}
     1247 */
     1248static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1249{
     1250    RT_NOREF(pThisCC);
     1251    *pResp = 0;
     1252
     1253    Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F02_PARAM_LENGTH);
     1254    if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F02_PARAM_LENGTH)
     1255    {
     1256        LogFlowFunc(("access to invalid F02 index %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
    12571257        return VINF_SUCCESS;
    12581258    }
    1259     *puResp = pThis->aNodes[CODEC_NID(uCmd)].node.au32F02_param[uCmd & CODEC_VERB_8BIT_DATA];
    1260     return VINF_SUCCESS;
    1261 }
    1262 
    1263 
    1264 /**
    1265  * @interface_method_impl{CODECVERB,pfn, f03}
    1266  */
    1267 static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1268 {
    1269     RT_NOREF(pThisCC);
    1270     *puResp = 0;
    1271 
    1272     if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1273         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adc.u32F03_param;
    1274 
    1275     return VINF_SUCCESS;
    1276 }
    1277 
    1278 
    1279 /**
    1280  * @interface_method_impl{CODECVERB,pfn, 703}
    1281  */
    1282 static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1283 {
    1284     RT_NOREF(pThisCC);
    1285     *puResp = 0;
    1286 
    1287     if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1288         hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(uCmd)].adc.u32F03_param, uCmd, 0);
    1289     return VINF_SUCCESS;
    1290 }
    1291 
    1292 
    1293 /**
    1294  * @interface_method_impl{CODECVERB,pfn, f0d}
    1295  */
    1296 static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1297 {
    1298     RT_NOREF(pThisCC);
    1299     *puResp = 0;
    1300 
    1301     if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1302         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F0d_param;
    1303     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1304         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F0d_param;
    1305     return VINF_SUCCESS;
    1306 }
    1307 
    1308 
    1309 static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t uCmd, uint8_t u8Offset, uint64_t *puResp)
    1310 {
    1311     *puResp = 0;
    1312 
    1313     if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1314         hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F0d_param, uCmd, u8Offset);
    1315     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1316         hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F0d_param, uCmd, u8Offset);
    1317     return VINF_SUCCESS;
    1318 }
    1319 
    1320 
    1321 /**
    1322  * @interface_method_impl{CODECVERB,pfn, 70d}
    1323  */
    1324 static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1325 {
    1326     RT_NOREF(pThisCC);
    1327     return codecSetDigitalConverter(pThis, uCmd, 0, puResp);
    1328 }
    1329 
    1330 
    1331 /**
    1332  * @interface_method_impl{CODECVERB,pfn, 70e}
    1333  */
    1334 static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1335 {
    1336     RT_NOREF(pThisCC);
    1337     return codecSetDigitalConverter(pThis, uCmd, 8, puResp);
    1338 }
    1339 
    1340 
    1341 /**
    1342  * @interface_method_impl{CODECVERB,pfn, f20}
    1343  */
    1344 static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1345 {
    1346     RT_NOREF(pThisCC);
    1347     Assert(CODEC_CAD(uCmd) == pThis->id);
     1259    *pResp = pThis->aNodes[CODEC_NID(cmd)].node.au32F02_param[cmd & CODEC_VERB_8BIT_DATA];
     1260    return VINF_SUCCESS;
     1261}
     1262
     1263
     1264/**
     1265 * @interface_method_impl{CODECVERB, pfn, f03}
     1266 */
     1267static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1268{
     1269    RT_NOREF(pThisCC);
     1270    *pResp = 0;
     1271
     1272    if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1273        *pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F03_param;
     1274
     1275    return VINF_SUCCESS;
     1276}
     1277
     1278
     1279/**
     1280 * @interface_method_impl{CODECVERB, pfn, 703}
     1281 */
     1282static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1283{
     1284    RT_NOREF(pThisCC);
     1285    *pResp = 0;
     1286
     1287    if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1288        hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
     1289    return VINF_SUCCESS;
     1290}
     1291
     1292
     1293/**
     1294 * @interface_method_impl{CODECVERB, pfn, f0d}
     1295 */
     1296static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1297{
     1298    RT_NOREF(pThisCC);
     1299    *pResp = 0;
     1300
     1301    if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1302        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
     1303    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1304        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
     1305
     1306    return VINF_SUCCESS;
     1307}
     1308
     1309
     1310static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
     1311{
     1312    *pResp = 0;
     1313
     1314    if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1315        hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
     1316    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1317        hdaCodecSetRegisterU8(&pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
     1318    return VINF_SUCCESS;
     1319}
     1320
     1321
     1322/**
     1323 * @interface_method_impl{CODECVERB, pfn, 70d}
     1324 */
     1325static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1326{
     1327    RT_NOREF(pThisCC);
     1328    return codecSetDigitalConverter(pThis, cmd, 0, pResp);
     1329}
     1330
     1331
     1332/**
     1333 * @interface_method_impl{CODECVERB, pfn, 70e}
     1334 */
     1335static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1336{
     1337    RT_NOREF(pThisCC);
     1338    return codecSetDigitalConverter(pThis, cmd, 8, pResp);
     1339}
     1340
     1341
     1342/**
     1343 * @interface_method_impl{CODECVERB, pfn, f20}
     1344 */
     1345static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1346{
     1347    RT_NOREF(pThisCC);
     1348    Assert(CODEC_CAD(cmd) == pThis->id);
    13481349    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    1349     Assert(CODEC_NID(uCmd) < cTotalNodes);
    1350     if (CODEC_NID(uCmd) >= cTotalNodes)
    1351     {
    1352         LogFlowFunc(("invalid node address %d\n", CODEC_NID(uCmd)));
    1353         *puResp = 0;
     1350    Assert(CODEC_NID(cmd) < cTotalNodes);
     1351    if (CODEC_NID(cmd) >= cTotalNodes)
     1352    {
     1353        LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
     1354        *pResp = 0;
    13541355        return VINF_SUCCESS;
    13551356    }
    1356     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1357         *puResp = pThis->aNodes[CODEC_NID(uCmd)].afg.u32F20_param;
    1358     else
    1359         *puResp = 0;
    1360     return VINF_SUCCESS;
    1361 }
    1362 
    1363 
    1364 static int codecSetSubIdX(PHDACODEC pThis, uint32_t uCmd, uint8_t u8Offset)
    1365 {
    1366     Assert(CODEC_CAD(uCmd) == pThis->id);
     1357    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1358        *pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F20_param;
     1359    else
     1360        *pResp = 0;
     1361    return VINF_SUCCESS;
     1362}
     1363
     1364
     1365static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
     1366{
     1367    Assert(CODEC_CAD(cmd) == pThis->id);
    13671368    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    1368     Assert(CODEC_NID(uCmd) < cTotalNodes);
    1369     if (CODEC_NID(uCmd) >= cTotalNodes)
    1370     {
    1371         LogFlowFunc(("invalid node address %d\n", CODEC_NID(uCmd)));
     1369    Assert(CODEC_NID(cmd) < cTotalNodes);
     1370    if (CODEC_NID(cmd) >= cTotalNodes)
     1371    {
     1372        LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
    13721373        return VINF_SUCCESS;
    13731374    }
    13741375    uint32_t *pu32Reg;
    1375     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1376         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].afg.u32F20_param;
     1376    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1377        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F20_param;
    13771378    else
    13781379        AssertFailedReturn(VINF_SUCCESS);
    1379     hdaCodecSetRegisterU8(pu32Reg, uCmd, u8Offset);
    1380     return VINF_SUCCESS;
    1381 }
    1382 
    1383 
    1384 /**
    1385  * @interface_method_impl{CODECVERB,pfn, 720}
    1386  */
    1387 static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1388 {
    1389     RT_NOREF(pThisCC);
    1390     *puResp = 0;
    1391     return codecSetSubIdX(pThis, uCmd, 0);
    1392 }
    1393 
    1394 
    1395 /**
    1396  * @interface_method_impl{CODECVERB,pfn, 721}
    1397  */
    1398 static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1399 {
    1400     RT_NOREF(pThisCC);
    1401     *puResp = 0;
    1402     return codecSetSubIdX(pThis, uCmd, 8);
    1403 }
    1404 
    1405 
    1406 /**
    1407  * @interface_method_impl{CODECVERB,pfn, 722}
    1408  */
    1409 static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1410 {
    1411     RT_NOREF(pThisCC);
    1412     *puResp = 0;
    1413     return codecSetSubIdX(pThis, uCmd, 16);
    1414 }
    1415 
    1416 
    1417 /**
    1418  * @interface_method_impl{CODECVERB,pfn, 723}
    1419  */
    1420 static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1421 {
    1422     RT_NOREF(pThisCC);
    1423     *puResp = 0;
    1424     return codecSetSubIdX(pThis, uCmd, 24);
    1425 }
    1426 
    1427 
    1428 /**
    1429  * @interface_method_impl{CODECVERB,pfn, ???}
    1430  */
    1431 static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1432 {
    1433     RT_NOREF(pThisCC);
    1434     Assert(CODEC_CAD(uCmd) == pThis->id);
     1380    hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
     1381    return VINF_SUCCESS;
     1382}
     1383
     1384
     1385/**
     1386 * @interface_method_impl{CODECVERB, pfn, 720}
     1387 */
     1388static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1389{
     1390    RT_NOREF(pThisCC);
     1391    *pResp = 0;
     1392    return codecSetSubIdX(pThis, cmd, 0);
     1393}
     1394
     1395
     1396/**
     1397 * @interface_method_impl{CODECVERB, pfn, 721}
     1398 */
     1399static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1400{
     1401    RT_NOREF(pThisCC);
     1402    *pResp = 0;
     1403    return codecSetSubIdX(pThis, cmd, 8);
     1404}
     1405
     1406
     1407/**
     1408 * @interface_method_impl{CODECVERB, pfn, 722}
     1409 */
     1410static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1411{
     1412    RT_NOREF(pThisCC);
     1413    *pResp = 0;
     1414    return codecSetSubIdX(pThis, cmd, 16);
     1415}
     1416
     1417
     1418/**
     1419 * @interface_method_impl{CODECVERB, pfn, 723}
     1420 */
     1421static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1422{
     1423    RT_NOREF(pThisCC);
     1424    *pResp = 0;
     1425    return codecSetSubIdX(pThis, cmd, 24);
     1426}
     1427
     1428
     1429/**
     1430 * @interface_method_impl{CODECVERB, pfn, ???}
     1431 */
     1432static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1433{
     1434    RT_NOREF(pThisCC);
     1435    Assert(CODEC_CAD(cmd) == pThis->id);
    14351436
    14361437    if (pThis->enmType == CODEC_TYPE_STAC9220)
    14371438    {
    1438         Assert(CODEC_NID(uCmd) == STAC9220_NID_AFG);
    1439 
    1440         if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
     1439        Assert(CODEC_NID(cmd) == STAC9220_NID_AFG);
     1440
     1441        if (CODEC_NID(cmd) == STAC9220_NID_AFG)
    14411442            stac9220Reset(pThis);
    14421443    }
    … …  
    14441445        AssertFailedReturn(VERR_NOT_IMPLEMENTED);
    14451446
    1446     *puResp = 0;
    1447     return VINF_SUCCESS;
    1448 }
    1449 
    1450 
    1451 /**
    1452  * @interface_method_impl{CODECVERB,pfn, f05}
    1453  */
    1454 static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1455 {
    1456     RT_NOREF(pThisCC);
    1457     *puResp = 0;
    1458 
    1459     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1460         *puResp = pThis->aNodes[CODEC_NID(uCmd)].afg.u32F05_param;
    1461     else if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1462         *puResp = pThis->aNodes[CODEC_NID(uCmd)].dac.u32F05_param;
    1463     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1464         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adc.u32F05_param;
    1465     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1466         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F05_param;
    1467     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1468         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digout.u32F05_param;
    1469     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1470         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F05_param;
    1471     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1472         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F05_param;
    1473     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1474         *puResp = pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F05_param;
    1475     else
    1476         LogRel2(("HDA: Warning: Unhandled get power state command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1447    *pResp = 0;
     1448    return VINF_SUCCESS;
     1449}
     1450
     1451
     1452/**
     1453 * @interface_method_impl{CODECVERB, pfn, f05}
     1454 */
     1455static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1456{
     1457    RT_NOREF(pThisCC);
     1458    *pResp = 0;
     1459
     1460    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1461        *pResp = pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
     1462    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1463        *pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
     1464    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1465        *pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
     1466    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1467        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
     1468    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1469        *pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F05_param;
     1470    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1471        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
     1472    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1473        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
     1474    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1475        *pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
     1476    else
     1477        LogRel2(("HDA: Warning: Unhandled get power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    14771478
    14781479    LogFunc(("[NID0x%02x]: fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
    1479              CODEC_NID(uCmd), CODEC_F05_IS_RESET(*puResp), CODEC_F05_IS_STOPOK(*puResp), CODEC_F05_ACT(*puResp), CODEC_F05_SET(*puResp)));
     1480             CODEC_NID(cmd), CODEC_F05_IS_RESET(*pResp), CODEC_F05_IS_STOPOK(*pResp), CODEC_F05_ACT(*pResp), CODEC_F05_SET(*pResp)));
    14801481    return VINF_SUCCESS;
    14811482}
    … …  
    14841485
    14851486/**
    1486  * @interface_method_impl{CODECVERB,pfn, 705}
    1487  */
    1488 static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1489 {
    1490     RT_NOREF(pThisCC);
    1491     *puResp = 0;
     1487 * @interface_method_impl{CODECVERB, pfn, 705}
     1488 */
     1489static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1490{
     1491    RT_NOREF(pThisCC);
     1492    *pResp = 0;
    14921493
    14931494    uint32_t *pu32Reg = NULL;
    1494     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1495         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].afg.u32F05_param;
    1496     else if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1497         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F05_param;
    1498     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1499         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F05_param;
    1500     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1501         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digout.u32F05_param;
    1502     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1503         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adc.u32F05_param;
    1504     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1505         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F05_param;
    1506     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1507         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F05_param;
    1508     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1509         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F05_param;
    1510     else
    1511     {
    1512         LogRel2(("HDA: Warning: Unhandled set power state command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1495    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1496        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
     1497    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1498        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
     1499    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1500        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
     1501    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1502        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F05_param;
     1503    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1504        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
     1505    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1506        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
     1507    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1508        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
     1509    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1510        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
     1511    else
     1512    {
     1513        LogRel2(("HDA: Warning: Unhandled set power state command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    15131514    }
    15141515
    … …  
    15161517        return VINF_SUCCESS;
    15171518
    1518     uint8_t uPwrCmd = CODEC_F05_SET      (uCmd);
     1519    uint8_t uPwrCmd = CODEC_F05_SET      (cmd);
    15191520    bool    fReset  = CODEC_F05_IS_RESET (*pu32Reg);
    15201521    bool    fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
    … …  
    15241525    uint8_t uPwrSet = CODEC_F05_SET      (*pu32Reg);
    15251526    LogFunc(("[NID0x%02x] Cmd=D%RU8, fReset=%RTbool, fStopOk=%RTbool, fError=%RTbool, uPwrAct=D%RU8, uPwrSet=D%RU8\n",
    1526              CODEC_NID(uCmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
     1527             CODEC_NID(cmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
    15271528    LogFunc(("AFG: Act=D%RU8, Set=D%RU8\n",
    15281529            CODEC_F05_ACT(pThis->aNodes[STAC9220_NID_AFG].afg.u32F05_param),
    … …  
    15301531#endif
    15311532
    1532     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
     1533    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
    15331534        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uPwrCmd /* PS-Act */, uPwrCmd /* PS-Set */);
    15341535
    … …  
    15761577
    15771578    LogFunc(("[NID0x%02x] fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
    1578              CODEC_NID(uCmd),
     1579             CODEC_NID(cmd),
    15791580             CODEC_F05_IS_RESET(*pu32Reg), CODEC_F05_IS_STOPOK(*pu32Reg), CODEC_F05_ACT(*pu32Reg), CODEC_F05_SET(*pu32Reg)));
    15801581
    … …  
    15971598
    15981599/**
    1599  * @interface_method_impl{CODECVERB,pfn, 705}
    1600  */
    1601 static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1602 {
    1603     RT_NOREF(pThisCC);
    1604     Assert(CODEC_CAD(uCmd) == pThis->id);
     1600 * @interface_method_impl{CODECVERB, pfn, 705}
     1601 */
     1602static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1603{
     1604    RT_NOREF(pThisCC);
     1605    Assert(CODEC_CAD(cmd) == pThis->id);
    16051606    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    1606     Assert(CODEC_NID(uCmd) < cTotalNodes);
    1607     if (CODEC_NID(uCmd) >= cTotalNodes)
    1608     {
    1609         *puResp = 0;
    1610         LogFlowFunc(("invalid node address %d\n", CODEC_NID(uCmd)));
     1607    Assert(CODEC_NID(cmd) < cTotalNodes);
     1608    if (CODEC_NID(cmd) >= cTotalNodes)
     1609    {
     1610        *pResp = 0;
     1611        LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
    16111612        return VINF_SUCCESS;
    16121613    }
    1613     *puResp = 0;
     1614    *pResp = 0;
    16141615    uint32_t *pu32Reg;
    1615     if (CODEC_NID(uCmd) == 1 /* AFG */)
    1616         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].afg.u32F05_param;
    1617     else if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1618         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F05_param;
    1619     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1620         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F05_param;
    1621     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1622         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adc.u32F05_param;
    1623     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1624         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F05_param;
    1625     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1626         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F05_param;
    1627     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1628         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F05_param;
     1616    if (CODEC_NID(cmd) == 1 /* AFG */)
     1617        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F05_param;
     1618    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1619        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F05_param;
     1620    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1621        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F05_param;
     1622    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1623        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F05_param;
     1624    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1625        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
     1626    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1627        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
     1628    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1629        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F05_param;
    16291630    else
    16301631        AssertFailedReturn(VINF_SUCCESS);
    … …  
    16331634    bool fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
    16341635
    1635     if (CODEC_NID(uCmd) != 1 /* AFG */)
     1636    if (CODEC_NID(cmd) != 1 /* AFG */)
    16361637    {
    16371638        /*
    … …  
    16401641        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0,
    16411642                                  CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param),
    1642                                   CODEC_F05_SET(uCmd));
     1643                                  CODEC_F05_SET(cmd));
    16431644    }
    16441645
    16451646    /* Propagate next power state only if AFG is on or verb modifies AFG power state */
    1646     if (   CODEC_NID(uCmd) == 1 /* AFG */
     1647    if (   CODEC_NID(cmd) == 1 /* AFG */
    16471648        || !CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param))
    16481649    {
    1649         *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(uCmd), CODEC_F05_SET(uCmd));
    1650         if (   CODEC_NID(uCmd) == 1 /* AFG */
    1651             && (CODEC_F05_SET(uCmd)) == CODEC_F05_D0)
     1650        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(cmd), CODEC_F05_SET(cmd));
     1651        if (   CODEC_NID(cmd) == 1 /* AFG */
     1652            && (CODEC_F05_SET(cmd)) == CODEC_F05_D0)
    16521653        {
    16531654            /* now we're powered on AFG and may propogate power states on nodes */
    … …  
    16711672
    16721673/**
    1673  * @interface_method_impl{CODECVERB,pfn, f06}
    1674  */
    1675 static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1676 {
    1677     RT_NOREF(pThisCC);
    1678     *puResp = 0;
    1679 
    1680     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1681         *puResp = pThis->aNodes[CODEC_NID(uCmd)].dac.u32F06_param;
    1682     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1683         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adc.u32F06_param;
    1684     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1685         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F06_param;
    1686     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1687         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F06_param;
    1688     else if (CODEC_NID(uCmd) == STAC9221_NID_I2S_OUT)
    1689         *puResp = pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F06_param;
    1690     else
    1691         LogRel2(("HDA: Warning: Unhandled get stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1674 * @interface_method_impl{CODECVERB, pfn, f06}
     1675 */
     1676static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1677{
     1678    RT_NOREF(pThisCC);
     1679    *pResp = 0;
     1680
     1681    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1682        *pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F06_param;
     1683    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1684        *pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32F06_param;
     1685    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1686        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
     1687    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1688        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
     1689    else if (CODEC_NID(cmd) == STAC9221_NID_I2S_OUT)
     1690        *pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F06_param;
     1691    else
     1692        LogRel2(("HDA: Warning: Unhandled get stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    16921693
    16931694    LogFlowFunc(("[NID0x%02x] Stream ID=%RU8, channel=%RU8\n",
    1694                  CODEC_NID(uCmd), CODEC_F00_06_GET_STREAM_ID(uCmd), CODEC_F00_06_GET_CHANNEL_ID(uCmd)));
    1695 
    1696     return VINF_SUCCESS;
    1697 }
    1698 
    1699 
    1700 /**
    1701  * @interface_method_impl{CODECVERB,pfn, a0}
    1702  */
    1703 static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1704 {
    1705     RT_NOREF(pThisCC);
    1706     *puResp = 0;
    1707 
    1708     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1709         *puResp = pThis->aNodes[CODEC_NID(uCmd)].dac.u32A_param;
    1710     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1711         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adc.u32A_param;
    1712     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1713         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32A_param;
    1714     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1715         *puResp = pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32A_param;
    1716     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1717         *puResp = pThis->aNodes[CODEC_NID(uCmd)].reserved.u32A_param;
    1718     else
    1719         LogRel2(("HDA: Warning: Unhandled get converter format command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1720 
    1721     return VINF_SUCCESS;
    1722 }
    1723 
    1724 
    1725 /**
    1726  * @interface_method_impl{CODECVERB,pfn, ??? - Also see section 3.7.1.}
    1727  */
    1728 static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1729 {
    1730     RT_NOREF(pThisCC);
    1731     *puResp = 0;
    1732 
    1733     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1734         hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(uCmd)].dac.u32A_param, uCmd, 0);
    1735     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    1736         hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(uCmd)].adc.u32A_param, uCmd, 0);
    1737     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    1738         hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32A_param, uCmd, 0);
    1739     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    1740         hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32A_param, uCmd, 0);
    1741     else
    1742         LogRel2(("HDA: Warning: Unhandled set converter format command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1743 
    1744     return VINF_SUCCESS;
    1745 }
    1746 
    1747 
    1748 /**
    1749  * @interface_method_impl{CODECVERB,pfn, f0c}
    1750  */
    1751 static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1752 {
    1753     RT_NOREF(pThisCC);
    1754     *puResp = 0;
    1755 
    1756     if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    1757         *puResp = pThis->aNodes[CODEC_NID(uCmd)].adcvol.u32F0c_param;
    1758     else if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1759         *puResp = pThis->aNodes[CODEC_NID(uCmd)].dac.u32F0c_param;
    1760     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1761         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F0c_param;
    1762     else
    1763         LogRel2(("HDA: Warning: Unhandled get EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1764 
    1765     return VINF_SUCCESS;
    1766 }
    1767 
    1768 
    1769 /**
    1770  * @interface_method_impl{CODECVERB,pfn, 70c}
    1771  */
    1772 static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1773 {
    1774     RT_NOREF(pThisCC);
    1775     *puResp = 0;
     1695                 CODEC_NID(cmd), CODEC_F00_06_GET_STREAM_ID(cmd), CODEC_F00_06_GET_CHANNEL_ID(cmd)));
     1696
     1697    return VINF_SUCCESS;
     1698}
     1699
     1700
     1701/**
     1702 * @interface_method_impl{CODECVERB, pfn, a0}
     1703 */
     1704static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1705{
     1706    RT_NOREF(pThisCC);
     1707    *pResp = 0;
     1708
     1709    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1710        *pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32A_param;
     1711    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1712        *pResp = pThis->aNodes[CODEC_NID(cmd)].adc.u32A_param;
     1713    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1714        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifout.u32A_param;
     1715    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1716        *pResp = pThis->aNodes[CODEC_NID(cmd)].spdifin.u32A_param;
     1717    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1718        *pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32A_param;
     1719    else
     1720        LogRel2(("HDA: Warning: Unhandled get converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1721
     1722    return VINF_SUCCESS;
     1723}
     1724
     1725
     1726/**
     1727 * @interface_method_impl{CODECVERB, pfn, ??? - Also see section 3.7.1.}
     1728 */
     1729static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1730{
     1731    RT_NOREF(pThisCC);
     1732    *pResp = 0;
     1733
     1734    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1735        hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
     1736    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     1737        hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
     1738    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     1739        hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
     1740    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     1741        hdaCodecSetRegisterU16(&pThis->aNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
     1742    else
     1743        LogRel2(("HDA: Warning: Unhandled set converter format command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1744
     1745    return VINF_SUCCESS;
     1746}
     1747
     1748
     1749/**
     1750 * @interface_method_impl{CODECVERB, pfn, f0c}
     1751 */
     1752static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1753{
     1754    RT_NOREF(pThisCC);
     1755    *pResp = 0;
     1756
     1757    if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     1758        *pResp = pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
     1759    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1760        *pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F0c_param;
     1761    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1762        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F0c_param;
     1763    else
     1764        LogRel2(("HDA: Warning: Unhandled get EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1765
     1766    return VINF_SUCCESS;
     1767}
     1768
     1769
     1770/**
     1771 * @interface_method_impl{CODECVERB, pfn, 70c}
     1772 */
     1773static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1774{
     1775    RT_NOREF(pThisCC);
     1776    *pResp = 0;
    17761777
    17771778    uint32_t *pu32Reg = NULL;
    1778     if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    1779         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].adcvol.u32F0c_param;
    1780     else if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    1781         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F0c_param;
    1782     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1783         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F0c_param;
    1784     else
    1785         LogRel2(("HDA: Warning: Unhandled set EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1779    if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     1780        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
     1781    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     1782        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F0c_param;
     1783    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1784        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F0c_param;
     1785    else
     1786        LogRel2(("HDA: Warning: Unhandled set EAPD/BTL enabled command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    17861787
    17871788    if (pu32Reg)
    1788         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1789 
    1790     return VINF_SUCCESS;
    1791 }
    1792 
    1793 
    1794 /**
    1795  * @interface_method_impl{CODECVERB,pfn, f0f}
    1796  */
    1797 static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1798 {
    1799     RT_NOREF(pThisCC);
    1800     *puResp = 0;
    1801 
    1802     if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(uCmd)))
    1803         *puResp = pThis->aNodes[CODEC_NID(uCmd)].volumeKnob.u32F0f_param;
    1804     else
    1805         LogRel2(("HDA: Warning: Unhandled get volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1806 
    1807     return VINF_SUCCESS;
    1808 }
    1809 
    1810 
    1811 /**
    1812  * @interface_method_impl{CODECVERB,pfn, 70f}
    1813  */
    1814 static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1815 {
    1816     RT_NOREF(pThisCC);
    1817     *puResp = 0;
     1789        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1790
     1791    return VINF_SUCCESS;
     1792}
     1793
     1794
     1795/**
     1796 * @interface_method_impl{CODECVERB, pfn, f0f}
     1797 */
     1798static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1799{
     1800    RT_NOREF(pThisCC);
     1801    *pResp = 0;
     1802
     1803    if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
     1804        *pResp = pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
     1805    else
     1806        LogRel2(("HDA: Warning: Unhandled get volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1807
     1808    return VINF_SUCCESS;
     1809}
     1810
     1811
     1812/**
     1813 * @interface_method_impl{CODECVERB, pfn, 70f}
     1814 */
     1815static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1816{
     1817    RT_NOREF(pThisCC);
     1818    *pResp = 0;
    18181819
    18191820    uint32_t *pu32Reg = NULL;
    1820     if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(uCmd)))
    1821         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].volumeKnob.u32F0f_param;
    1822     else
    1823         LogRel2(("HDA: Warning: Unhandled set volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1821    if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
     1822        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
     1823    else
     1824        LogRel2(("HDA: Warning: Unhandled set volume knob control command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    18241825
    18251826    if (pu32Reg)
    1826         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1827 
    1828     return VINF_SUCCESS;
    1829 }
    1830 
    1831 
    1832 /**
    1833  * @interface_method_impl{CODECVERB,pfn, f15}
    1834  */
    1835 static DECLCALLBACK(int) vrbProcGetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1836 {
    1837     RT_NOREF(pThis, pThisCC, uCmd);
    1838     *puResp = 0;
    1839     return VINF_SUCCESS;
    1840 }
    1841 
    1842 
    1843 /**
    1844  * @interface_method_impl{CODECVERB,pfn, 715}
    1845  */
    1846 static DECLCALLBACK(int) vrbProcSetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1847 {
    1848     RT_NOREF(pThis, pThisCC, uCmd);
    1849     *puResp = 0;
    1850     return VINF_SUCCESS;
    1851 }
    1852 
    1853 
    1854 /**
    1855  * @interface_method_impl{CODECVERB,pfn, f16}
    1856  */
    1857 static DECLCALLBACK(int) vrbProcGetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1858 {
    1859     RT_NOREF(pThis, pThisCC, uCmd);
    1860     *puResp = 0;
    1861     return VINF_SUCCESS;
    1862 }
    1863 
    1864 
    1865 /**
    1866  * @interface_method_impl{CODECVERB,pfn, 716}
    1867  */
    1868 static DECLCALLBACK(int) vrbProcSetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1869 {
    1870     RT_NOREF(pThis, pThisCC, uCmd);
    1871     *puResp = 0;
    1872     return VINF_SUCCESS;
    1873 }
    1874 
    1875 
    1876 /**
    1877  * @interface_method_impl{CODECVERB,pfn, f17}
    1878  */
    1879 static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1880 {
    1881     RT_NOREF(pThisCC);
    1882     *puResp = 0;
     1827        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1828
     1829    return VINF_SUCCESS;
     1830}
     1831
     1832
     1833/**
     1834 * @interface_method_impl{CODECVERB, pfn, f15}
     1835 */
     1836static DECLCALLBACK(int) vrbProcGetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1837{
     1838    RT_NOREF(pThis, pThisCC, cmd);
     1839    *pResp = 0;
     1840    return VINF_SUCCESS;
     1841}
     1842
     1843
     1844/**
     1845 * @interface_method_impl{CODECVERB, pfn, 715}
     1846 */
     1847static DECLCALLBACK(int) vrbProcSetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1848{
     1849    RT_NOREF(pThis, pThisCC, cmd);
     1850    *pResp = 0;
     1851    return VINF_SUCCESS;
     1852}
     1853
     1854
     1855/**
     1856 * @interface_method_impl{CODECVERB, pfn, f16}
     1857 */
     1858static DECLCALLBACK(int) vrbProcGetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1859{
     1860    RT_NOREF(pThis, pThisCC, cmd);
     1861    *pResp = 0;
     1862    return VINF_SUCCESS;
     1863}
     1864
     1865
     1866/**
     1867 * @interface_method_impl{CODECVERB, pfn, 716}
     1868 */
     1869static DECLCALLBACK(int) vrbProcSetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1870{
     1871    RT_NOREF(pThis, pThisCC, cmd);
     1872    *pResp = 0;
     1873    return VINF_SUCCESS;
     1874}
     1875
     1876
     1877/**
     1878 * @interface_method_impl{CODECVERB, pfn, f17}
     1879 */
     1880static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1881{
     1882    RT_NOREF(pThisCC);
     1883    *pResp = 0;
    18831884
    18841885    /* Note: this is true for ALC885. */
    1885     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    1886         *puResp = pThis->aNodes[1].afg.u32F17_param;
    1887     else
    1888         LogRel2(("HDA: Warning: Unhandled get GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1889 
    1890     return VINF_SUCCESS;
    1891 }
    1892 
    1893 
    1894 /**
    1895  * @interface_method_impl{CODECVERB,pfn, 717}
    1896  */
    1897 static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1898 {
    1899     RT_NOREF(pThisCC);
    1900     *puResp = 0;
     1886    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1887        *pResp = pThis->aNodes[1].afg.u32F17_param;
     1888    else
     1889        LogRel2(("HDA: Warning: Unhandled get GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1890
     1891    return VINF_SUCCESS;
     1892}
     1893
     1894
     1895/**
     1896 * @interface_method_impl{CODECVERB, pfn, 717}
     1897 */
     1898static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1899{
     1900    RT_NOREF(pThisCC);
     1901    *pResp = 0;
    19011902
    19021903    uint32_t *pu32Reg = NULL;
    1903     if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
     1904    if (CODEC_NID(cmd) == STAC9220_NID_AFG)
    19041905        pu32Reg = &pThis->aNodes[1].afg.u32F17_param;
    19051906    else
    1906         LogRel2(("HDA: Warning: Unhandled set GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     1907        LogRel2(("HDA: Warning: Unhandled set GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    19071908
    19081909    if (pu32Reg)
    1909         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    1910 
    1911     return VINF_SUCCESS;
    1912 }
    1913 
    1914 
    1915 /**
    1916  * @interface_method_impl{CODECVERB,pfn, f1c}
    1917  */
    1918 static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1919 {
    1920     RT_NOREF(pThisCC);
    1921     *puResp = 0;
    1922 
    1923     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1924         *puResp = pThis->aNodes[CODEC_NID(uCmd)].port.u32F1c_param;
    1925     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1926         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digout.u32F1c_param;
    1927     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1928         *puResp = pThis->aNodes[CODEC_NID(uCmd)].digin.u32F1c_param;
    1929     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    1930         *puResp = pThis->aNodes[CODEC_NID(uCmd)].pcbeep.u32F1c_param;
    1931     else if (hdaCodecIsCdNode(pThis, CODEC_NID(uCmd)))
    1932         *puResp = pThis->aNodes[CODEC_NID(uCmd)].cdnode.u32F1c_param;
    1933     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1934         *puResp = pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F1c_param;
    1935     else
    1936         LogRel2(("HDA: Warning: Unhandled get config command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    1937 
    1938     return VINF_SUCCESS;
    1939 }
    1940 
    1941 static int codecSetConfigX(PHDACODEC pThis, uint32_t uCmd, uint8_t u8Offset)
     1910        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1911
     1912    return VINF_SUCCESS;
     1913}
     1914
     1915
     1916/**
     1917 * @interface_method_impl{CODECVERB, pfn, f1c}
     1918 */
     1919static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1920{
     1921    RT_NOREF(pThisCC);
     1922    *pResp = 0;
     1923
     1924    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1925        *pResp = pThis->aNodes[CODEC_NID(cmd)].port.u32F1c_param;
     1926    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1927        *pResp = pThis->aNodes[CODEC_NID(cmd)].digout.u32F1c_param;
     1928    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1929        *pResp = pThis->aNodes[CODEC_NID(cmd)].digin.u32F1c_param;
     1930    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     1931        *pResp = pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
     1932    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
     1933        *pResp = pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
     1934    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1935        *pResp = pThis->aNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
     1936    else
     1937        LogRel2(("HDA: Warning: Unhandled get config command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1938
     1939    return VINF_SUCCESS;
     1940}
     1941
     1942static int codecSetConfigX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
    19421943{
    19431944    uint32_t *pu32Reg = NULL;
    1944     if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    1945         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].port.u32F1c_param;
    1946     else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(uCmd)))
    1947         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digin.u32F1c_param;
    1948     else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(uCmd)))
    1949         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].digout.u32F1c_param;
    1950     else if (hdaCodecIsCdNode(pThis, CODEC_NID(uCmd)))
    1951         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].cdnode.u32F1c_param;
    1952     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    1953         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].pcbeep.u32F1c_param;
    1954     else if (hdaCodecIsReservedNode(pThis, CODEC_NID(uCmd)))
    1955         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].reserved.u32F1c_param;
    1956     else
    1957         LogRel2(("HDA: Warning: Unhandled set config command (%RU8) for NID0x%02x: 0x%x\n", u8Offset, CODEC_NID(uCmd), uCmd));
     1945    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     1946        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].port.u32F1c_param;
     1947    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
     1948        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digin.u32F1c_param;
     1949    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
     1950        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].digout.u32F1c_param;
     1951    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
     1952        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
     1953    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     1954        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
     1955    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
     1956        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
     1957    else
     1958        LogRel2(("HDA: Warning: Unhandled set config command (%RU8) for NID0x%02x: 0x%x\n", u8Offset, CODEC_NID(cmd), cmd));
    19581959
    19591960    if (pu32Reg)
    1960         hdaCodecSetRegisterU8(pu32Reg, uCmd, u8Offset);
    1961 
    1962     return VINF_SUCCESS;
    1963 }
    1964 
    1965 
    1966 /**
    1967  * @interface_method_impl{CODECVERB,pfn, 71c}
    1968  */
    1969 static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1970 {
    1971     RT_NOREF(pThisCC);
    1972     *puResp = 0;
    1973     return codecSetConfigX(pThis, uCmd, 0);
    1974 }
    1975 
    1976 
    1977 /**
    1978  * @interface_method_impl{CODECVERB,pfn, 71d}
    1979  */
    1980 static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1981 {
    1982     RT_NOREF(pThisCC);
    1983     *puResp = 0;
    1984     return codecSetConfigX(pThis, uCmd, 8);
    1985 }
    1986 
    1987 
    1988 /**
    1989  * @interface_method_impl{CODECVERB,pfn, 71e}
    1990  */
    1991 static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    1992 {
    1993     RT_NOREF(pThisCC);
    1994     *puResp = 0;
    1995     return codecSetConfigX(pThis, uCmd, 16);
    1996 }
    1997 
    1998 
    1999 /**
    2000  * @interface_method_impl{CODECVERB,pfn, 71e}
    2001  */
    2002 static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2003 {
    2004     RT_NOREF(pThisCC);
    2005     *puResp = 0;
    2006     return codecSetConfigX(pThis, uCmd, 24);
    2007 }
    2008 
    2009 
    2010 /**
    2011  * @interface_method_impl{CODECVERB,pfn, f04}
    2012  */
    2013 static DECLCALLBACK(int) vrbProcGetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2014 {
    2015     RT_NOREF(pThisCC);
    2016     *puResp = 0;
    2017 
    2018     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    2019         *puResp = pThis->aNodes[CODEC_NID(uCmd)].dac.u32F04_param;
    2020     else
    2021         LogRel2(("HDA: Warning: Unhandled get SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    2022 
    2023     return VINF_SUCCESS;
    2024 }
    2025 
    2026 
    2027 /**
    2028  * @interface_method_impl{CODECVERB,pfn, 704}
    2029  */
    2030 static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2031 {
    2032     RT_NOREF(pThisCC);
    2033     *puResp = 0;
     1961        hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
     1962
     1963    return VINF_SUCCESS;
     1964}
     1965
     1966
     1967/**
     1968 * @interface_method_impl{CODECVERB, pfn, 71c}
     1969 */
     1970static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1971{
     1972    RT_NOREF(pThisCC);
     1973    *pResp = 0;
     1974    return codecSetConfigX(pThis, cmd, 0);
     1975}
     1976
     1977
     1978/**
     1979 * @interface_method_impl{CODECVERB, pfn, 71d}
     1980 */
     1981static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1982{
     1983    RT_NOREF(pThisCC);
     1984    *pResp = 0;
     1985    return codecSetConfigX(pThis, cmd, 8);
     1986}
     1987
     1988
     1989/**
     1990 * @interface_method_impl{CODECVERB, pfn, 71e}
     1991 */
     1992static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     1993{
     1994    RT_NOREF(pThisCC);
     1995    *pResp = 0;
     1996    return codecSetConfigX(pThis, cmd, 16);
     1997}
     1998
     1999
     2000/**
     2001 * @interface_method_impl{CODECVERB, pfn, 71e}
     2002 */
     2003static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     2004{
     2005    RT_NOREF(pThisCC);
     2006    *pResp = 0;
     2007    return codecSetConfigX(pThis, cmd, 24);
     2008}
     2009
     2010
     2011/**
     2012 * @interface_method_impl{CODECVERB, pfn, f04}
     2013 */
     2014static DECLCALLBACK(int) vrbProcGetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     2015{
     2016    RT_NOREF(pThisCC);
     2017    *pResp = 0;
     2018
     2019    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     2020        *pResp = pThis->aNodes[CODEC_NID(cmd)].dac.u32F04_param;
     2021    else
     2022        LogRel2(("HDA: Warning: Unhandled get SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     2023
     2024    return VINF_SUCCESS;
     2025}
     2026
     2027
     2028/**
     2029 * @interface_method_impl{CODECVERB, pfn, 704}
     2030 */
     2031static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     2032{
     2033    RT_NOREF(pThisCC);
     2034    *pResp = 0;
    20342035
    20352036    uint32_t *pu32Reg = NULL;
    2036     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    2037         pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F04_param;
    2038     else
    2039         LogRel2(("HDA: Warning: Unhandled set SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     2037    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     2038        pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F04_param;
     2039    else
     2040        LogRel2(("HDA: Warning: Unhandled set SDI select command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    20402041
    20412042    if (pu32Reg)
    2042         hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
     2043        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    20432044
    20442045    return VINF_SUCCESS;
    … …  
    20482049
    20492050/**
    2050  * @interface_method_impl{CODECVERB,pfn, 3--}
    2051  */
    2052 static DECLCALLBACK(int) vrbProcR3SetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2053 {
    2054     *puResp = 0;
    2055 
    2056     PCODECNODE pNode      = &pThis->aNodes[CODEC_NID(uCmd)];
     2051 * @interface_method_impl{CODECVERB, pfn, 3--}
     2052 */
     2053static DECLCALLBACK(int) vrbProcR3SetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     2054{
     2055    *pResp = 0;
     2056
     2057    PCODECNODE pNode      = &pThis->aNodes[CODEC_NID(cmd)];
    20572058    AMPLIFIER *pAmplifier = NULL;
    2058     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
     2059    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
    20592060        pAmplifier = &pNode->dac.B_params;
    2060     else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
     2061    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
    20612062        pAmplifier = &pNode->adcvol.B_params;
    2062     else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(uCmd)))
     2063    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
    20632064        pAmplifier = &pNode->adcmux.B_params;
    2064     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
     2065    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
    20652066        pAmplifier = &pNode->pcbeep.B_params;
    2066     else if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
     2067    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
    20672068        pAmplifier = &pNode->port.B_params;
    2068     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
     2069    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
    20692070        pAmplifier = &pNode->adc.B_params;
    20702071    else
    20712072        LogRel2(("HDA: Warning: Unhandled set amplifier command: 0x%x (Payload=%RU16, NID=0x%x [%RU8])\n",
    2072                  uCmd, CODEC_VERB_PAYLOAD16(uCmd), CODEC_NID(uCmd), CODEC_NID(uCmd)));
     2073                 cmd, CODEC_VERB_PAYLOAD16(cmd), CODEC_NID(cmd), CODEC_NID(cmd)));
    20732074
    20742075    if (!pAmplifier)
    20752076        return VINF_SUCCESS;
    20762077
    2077     bool fIsOut     = CODEC_SET_AMP_IS_OUT_DIRECTION(uCmd);
    2078     bool fIsIn      = CODEC_SET_AMP_IS_IN_DIRECTION(uCmd);
    2079     bool fIsLeft    = CODEC_SET_AMP_IS_LEFT_SIDE(uCmd);
    2080     bool fIsRight   = CODEC_SET_AMP_IS_RIGHT_SIDE(uCmd);
    2081     uint8_t u8Index = CODEC_SET_AMP_INDEX(uCmd);
     2078    bool fIsOut     = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
     2079    bool fIsIn      = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
     2080    bool fIsLeft    = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
     2081    bool fIsRight   = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
     2082    uint8_t u8Index = CODEC_SET_AMP_INDEX(cmd);
    20822083
    20832084    if (   (!fIsLeft && !fIsRight)
    … …  
    20862087
    20872088    LogFunc(("[NID0x%02x] fIsOut=%RTbool, fIsIn=%RTbool, fIsLeft=%RTbool, fIsRight=%RTbool, Idx=%RU8\n",
    2088              CODEC_NID(uCmd), fIsOut, fIsIn, fIsLeft, fIsRight, u8Index));
     2089             CODEC_NID(cmd), fIsOut, fIsIn, fIsLeft, fIsRight, u8Index));
    20892090
    20902091    if (fIsIn)
    20912092    {
    20922093        if (fIsLeft)
    2093             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), uCmd, 0);
     2094            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
    20942095        if (fIsRight)
    2095             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
    2096 
    2097     //    if (CODEC_NID(uCmd) == pThis->u8AdcVolsLineIn)
     2096            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
     2097
     2098    //    if (CODEC_NID(cmd) == pThis->u8AdcVolsLineIn)
    20982099    //    {
    20992100            hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_LINE_IN);
    … …  
    21032104    {
    21042105        if (fIsLeft)
    2105             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), uCmd, 0);
     2106            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
    21062107        if (fIsRight)
    2107             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
    2108 
    2109         if (CODEC_NID(uCmd) == pThis->u8DacLineOut)
     2108            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
     2109
     2110        if (CODEC_NID(cmd) == pThis->u8DacLineOut)
    21102111            hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_FRONT);
    21112112    }
    … …  
    21162117
    21172118/**
    2118  * @interface_method_impl{CODECVERB,pfn, 706}
    2119  */
    2120 static DECLCALLBACK(int) vrbProcR3SetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2121 {
    2122     *puResp = 0;
    2123 
    2124     uint8_t uSD      = CODEC_F00_06_GET_STREAM_ID(uCmd);
    2125     uint8_t uChannel = CODEC_F00_06_GET_CHANNEL_ID(uCmd);
     2119 * @interface_method_impl{CODECVERB, pfn, 706}
     2120 */
     2121static DECLCALLBACK(int) vrbProcR3SetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     2122{
     2123    *pResp = 0;
     2124
     2125    uint8_t uSD      = CODEC_F00_06_GET_STREAM_ID(cmd);
     2126    uint8_t uChannel = CODEC_F00_06_GET_CHANNEL_ID(cmd);
    21262127
    21272128    LogFlowFunc(("[NID0x%02x] Setting to stream ID=%RU8, channel=%RU8\n",
    2128                  CODEC_NID(uCmd), uSD, uChannel));
     2129                 CODEC_NID(cmd), uSD, uChannel));
    21292130
    21302131    ASSERT_GUEST_LOGREL_MSG_RETURN(uSD < HDA_MAX_STREAMS,
    … …  
    21332134    PDMAUDIODIR enmDir;
    21342135    uint32_t   *pu32Addr;
    2135     if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    2136     {
    2137         pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F06_param;
     2136    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     2137    {
     2138        pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F06_param;
    21382139        enmDir = PDMAUDIODIR_OUT;
    21392140    }
    2140     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    2141     {
    2142         pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].adc.u32F06_param;
     2141    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     2142    {
     2143        pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F06_param;
    21432144        enmDir = PDMAUDIODIR_IN;
    21442145    }
    2145     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
    2146     {
    2147         pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F06_param;
     2146    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
     2147    {
     2148        pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
    21482149        enmDir = PDMAUDIODIR_OUT;
    21492150    }
    2150     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
    2151     {
    2152         pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F06_param;
     2151    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
     2152    {
     2153        pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
    21532154        enmDir = PDMAUDIODIR_IN;
    21542155    }
    … …  
    21562157    {
    21572158        enmDir = PDMAUDIODIR_UNKNOWN;
    2158         LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
     2159        LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
    21592160        return VINF_SUCCESS;
    21602161    }
    21612162
    21622163    /* Do we (re-)assign our input/output SDn (SDI/SDO) IDs? */
    2163     pThis->aNodes[CODEC_NID(uCmd)].node.uSD      = uSD;
    2164     pThis->aNodes[CODEC_NID(uCmd)].node.uChannel = uChannel;
     2164    pThis->aNodes[CODEC_NID(cmd)].node.uSD      = uSD;
     2165    pThis->aNodes[CODEC_NID(cmd)].node.uChannel = uChannel;
    21652166
    21662167    if (enmDir == PDMAUDIODIR_OUT)
    … …  
    21832184    }
    21842185
    2185     hdaCodecSetRegisterU8(pu32Addr, uCmd, 0);
     2186    hdaCodecSetRegisterU8(pu32Addr, cmd, 0);
    21862187
    21872188    return VINF_SUCCESS;
    … …  
    22512252
    22522253/**
    2253  * Implements codec lookup and will call the handler on the verb it finds,
    2254  * returning the handler response.
    2255  *
    2256  * @returns VBox status code (not strict).
     2254 * Implements
    22572255 */
    22582256static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)

  • trunk/src/VBox/Devices/Audio/DevHdaCodec.h

    r90120 r90121  
    571571     * Function pointer for implementation callback.
    572572     *
    573      * This is always a valid pointer in ring-3, while elsewhere a NULL indicates
     573     * This is always a valid  pointer in ring-3, while elsewhere a NULL indicates
    574574     * that we must return to ring-3 to process it.
    575575     */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette