VirtualBox

Changeset 90122 in vbox for trunk


Ignore:
Timestamp:
Jul 9, 2021 12:47:32 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
145624
Message:

DevHdaCodec: More doxygen stuff. Renamed callback parameters to match prototype. bugref:9890

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

Legend:

Unmodified
Added
Removed

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

    r90121 r90122  
    932932
    933933/**
    934  * @interface_method_impl{CODECVERB, pfn, Unimplemented}
    935  */
    936 static 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  */
    949 static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
     934 * @interface_method_impl{CODECVERB,pfn, Unimplemented}
     935 */
     936static 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 */
     949static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    950950{
    951951    int rc;
    952     rc = vrbProcUnimplemented(pThis, pThisCC, cmd, pResp);
    953     *pResp |= CODEC_RESPONSE_UNSOLICITED;
     952    rc = vrbProcUnimplemented(pThis, pThisCC, uCmd, puResp);
     953    *puResp |= 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 cmd, uint64_t *pResp)
    963 {
    964     RT_NOREF(pThisCC);
    965     *pResp = 0;
     960 * @interface_method_impl{CODECVERB,pfn, b--}
     961 */
     962static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     963{
     964    RT_NOREF(pThisCC);
     965    *puResp = 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(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  */
    1012 static 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)));
     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 */
     1012static 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)));
    10211021        return VINF_SUCCESS;
    10221022    }
    10231023
    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  */
    1032 static 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  */
    1057 static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1058 {
    1059     RT_NOREF(pThisCC);
    1060     *pResp = 0;
     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 */
     1032static 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 */
     1057static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1058{
     1059    RT_NOREF(pThisCC);
     1060    *puResp = 0;
    10611061
    10621062    uint32_t *pu32Reg = NULL;
    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));
     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));
    10751075
    10761076    if (pu32Reg)
    1077         hdaCodecSetRegisterU8(pu32Reg, cmd, 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 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  */
    1113 static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1114 {
    1115     RT_NOREF(pThisCC);
    1116     *pResp = 0;
     1077        hdaCodecSetRegisterU8(pu32Reg, uCmd, 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 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 */
     1113static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1114{
     1115    RT_NOREF(pThisCC);
     1116    *puResp = 0;
    11171117
    11181118    uint32_t *pu32Reg = NULL;
    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));
     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));
    11341134
    11351135    if (pu32Reg)
    1136         hdaCodecSetRegisterU8(pu32Reg, cmd, 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 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  */
    1172 static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1173 {
    1174     RT_NOREF(pThisCC);
    1175     *pResp = 0;
     1136        hdaCodecSetRegisterU8(pu32Reg, uCmd, 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 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 */
     1172static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1173{
     1174    RT_NOREF(pThisCC);
     1175    *puResp = 0;
    11761176
    11771177    uint32_t *pu32Reg = NULL;
    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));
     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));
    11921192
    11931193    if (pu32Reg)
    1194         hdaCodecSetRegisterU8(pu32Reg, cmd, 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 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;
     1194        hdaCodecSetRegisterU8(pu32Reg, uCmd, 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 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;
    12121212    else
    12131213    {
    12141214        AssertFailed();
    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  */
    1225 static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1226 {
    1227     RT_NOREF(pThisCC);
    1228     *pResp = 0;
     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 */
     1225static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1226{
     1227    RT_NOREF(pThisCC);
     1228    *puResp = 0;
    12291229
    12301230    uint32_t *pu32Reg = NULL;
    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));
     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));
    12371237
    12381238    if (pu32Reg)
    1239         hdaCodecSetRegisterU8(pu32Reg, cmd, 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 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)));
     1239        hdaCodecSetRegisterU8(pu32Reg, uCmd, 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 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)));
    12571257        return VINF_SUCCESS;
    12581258    }
    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  */
    1267 static 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  */
    1282 static 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  */
    1296 static 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 
    1310 static 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  */
    1325 static 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  */
    1335 static 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  */
    1345 static 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);
     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 */
     1267static 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 */
     1282static 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 */
     1296static 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
     1309static 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 */
     1324static 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 */
     1334static 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 */
     1344static 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);
    13491348    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    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;
     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;
    13551354        return VINF_SUCCESS;
    13561355    }
    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 
    1365 static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
    1366 {
    1367     Assert(CODEC_CAD(cmd) == pThis->id);
     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
     1364static int codecSetSubIdX(PHDACODEC pThis, uint32_t uCmd, uint8_t u8Offset)
     1365{
     1366    Assert(CODEC_CAD(uCmd) == pThis->id);
    13681367    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    1369     Assert(CODEC_NID(cmd) < cTotalNodes);
    1370     if (CODEC_NID(cmd) >= cTotalNodes)
    1371     {
    1372         LogFlowFunc(("invalid node address %d\n", CODEC_NID(cmd)));
     1368    Assert(CODEC_NID(uCmd) < cTotalNodes);
     1369    if (CODEC_NID(uCmd) >= cTotalNodes)
     1370    {
     1371        LogFlowFunc(("invalid node address %d\n", CODEC_NID(uCmd)));
    13731372        return VINF_SUCCESS;
    13741373    }
    13751374    uint32_t *pu32Reg;
    1376     if (CODEC_NID(cmd) == STAC9220_NID_AFG)
    1377         pu32Reg = &pThis->aNodes[CODEC_NID(cmd)].afg.u32F20_param;
     1375    if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
     1376        pu32Reg = &pThis->aNodes[CODEC_NID(uCmd)].afg.u32F20_param;
    13781377    else
    13791378        AssertFailedReturn(VINF_SUCCESS);
    1380     hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
    1381     return VINF_SUCCESS;
    1382 }
    1383 
    1384 
    1385 /**
    1386  * @interface_method_impl{CODECVERB, pfn, 720}
    1387  */
    1388 static 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  */
    1399 static 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  */
    1410 static 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  */
    1421 static 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  */
    1432 static 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);
     1379    hdaCodecSetRegisterU8(pu32Reg, uCmd, u8Offset);
     1380    return VINF_SUCCESS;
     1381}
     1382
     1383
     1384/**
     1385 * @interface_method_impl{CODECVERB,pfn, 720}
     1386 */
     1387static 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 */
     1398static 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 */
     1409static 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 */
     1420static 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 */
     1431static 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);
    14361435
    14371436    if (pThis->enmType == CODEC_TYPE_STAC9220)
    14381437    {
    1439         Assert(CODEC_NID(cmd) == STAC9220_NID_AFG);
    1440 
    1441         if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1438        Assert(CODEC_NID(uCmd) == STAC9220_NID_AFG);
     1439
     1440        if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    14421441            stac9220Reset(pThis);
    14431442    }
    … …  
    14451444        AssertFailedReturn(VERR_NOT_IMPLEMENTED);
    14461445
    1447     *pResp = 0;
    1448     return VINF_SUCCESS;
    1449 }
    1450 
    1451 
    1452 /**
    1453  * @interface_method_impl{CODECVERB, pfn, f05}
    1454  */
    1455 static 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));
     1446    *puResp = 0;
     1447    return VINF_SUCCESS;
     1448}
     1449
     1450
     1451/**
     1452 * @interface_method_impl{CODECVERB,pfn, f05}
     1453 */
     1454static 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));
    14781477
    14791478    LogFunc(("[NID0x%02x]: fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
    1480              CODEC_NID(cmd), CODEC_F05_IS_RESET(*pResp), CODEC_F05_IS_STOPOK(*pResp), CODEC_F05_ACT(*pResp), CODEC_F05_SET(*pResp)));
     1479             CODEC_NID(uCmd), CODEC_F05_IS_RESET(*puResp), CODEC_F05_IS_STOPOK(*puResp), CODEC_F05_ACT(*puResp), CODEC_F05_SET(*puResp)));
    14811480    return VINF_SUCCESS;
    14821481}
    … …  
    14851484
    14861485/**
    1487  * @interface_method_impl{CODECVERB, pfn, 705}
    1488  */
    1489 static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1490 {
    1491     RT_NOREF(pThisCC);
    1492     *pResp = 0;
     1486 * @interface_method_impl{CODECVERB,pfn, 705}
     1487 */
     1488static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1489{
     1490    RT_NOREF(pThisCC);
     1491    *puResp = 0;
    14931492
    14941493    uint32_t *pu32Reg = NULL;
    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));
     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));
    15141513    }
    15151514
    … …  
    15171516        return VINF_SUCCESS;
    15181517
    1519     uint8_t uPwrCmd = CODEC_F05_SET      (cmd);
     1518    uint8_t uPwrCmd = CODEC_F05_SET      (uCmd);
    15201519    bool    fReset  = CODEC_F05_IS_RESET (*pu32Reg);
    15211520    bool    fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
    … …  
    15251524    uint8_t uPwrSet = CODEC_F05_SET      (*pu32Reg);
    15261525    LogFunc(("[NID0x%02x] Cmd=D%RU8, fReset=%RTbool, fStopOk=%RTbool, fError=%RTbool, uPwrAct=D%RU8, uPwrSet=D%RU8\n",
    1527              CODEC_NID(cmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
     1526             CODEC_NID(uCmd), uPwrCmd, fReset, fStopOk, fError, uPwrAct, uPwrSet));
    15281527    LogFunc(("AFG: Act=D%RU8, Set=D%RU8\n",
    15291528            CODEC_F05_ACT(pThis->aNodes[STAC9220_NID_AFG].afg.u32F05_param),
    … …  
    15311530#endif
    15321531
    1533     if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1532    if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    15341533        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, uPwrCmd /* PS-Act */, uPwrCmd /* PS-Set */);
    15351534
    … …  
    15771576
    15781577    LogFunc(("[NID0x%02x] fReset=%RTbool, fStopOk=%RTbool, Act=D%RU8, Set=D%RU8\n",
    1579              CODEC_NID(cmd),
     1578             CODEC_NID(uCmd),
    15801579             CODEC_F05_IS_RESET(*pu32Reg), CODEC_F05_IS_STOPOK(*pu32Reg), CODEC_F05_ACT(*pu32Reg), CODEC_F05_SET(*pu32Reg)));
    15811580
    … …  
    15981597
    15991598/**
    1600  * @interface_method_impl{CODECVERB, pfn, 705}
    1601  */
    1602 static 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);
     1599 * @interface_method_impl{CODECVERB,pfn, 705}
     1600 */
     1601static 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);
    16061605    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    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)));
     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)));
    16121611        return VINF_SUCCESS;
    16131612    }
    1614     *pResp = 0;
     1613    *puResp = 0;
    16151614    uint32_t *pu32Reg;
    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;
     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;
    16301629    else
    16311630        AssertFailedReturn(VINF_SUCCESS);
    … …  
    16341633    bool fStopOk = CODEC_F05_IS_STOPOK(*pu32Reg);
    16351634
    1636     if (CODEC_NID(cmd) != 1 /* AFG */)
     1635    if (CODEC_NID(uCmd) != 1 /* AFG */)
    16371636    {
    16381637        /*
    … …  
    16411640        *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0,
    16421641                                  CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param),
    1643                                   CODEC_F05_SET(cmd));
     1642                                  CODEC_F05_SET(uCmd));
    16441643    }
    16451644
    16461645    /* Propagate next power state only if AFG is on or verb modifies AFG power state */
    1647     if (   CODEC_NID(cmd) == 1 /* AFG */
     1646    if (   CODEC_NID(uCmd) == 1 /* AFG */
    16481647        || !CODEC_F05_ACT(pThis->aNodes[1].afg.u32F05_param))
    16491648    {
    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)
     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)
    16531652        {
    16541653            /* now we're powered on AFG and may propogate power states on nodes */
    … …  
    16721671
    16731672/**
    1674  * @interface_method_impl{CODECVERB, pfn, f06}
    1675  */
    1676 static 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));
     1673 * @interface_method_impl{CODECVERB,pfn, f06}
     1674 */
     1675static 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));
    16931692
    16941693    LogFlowFunc(("[NID0x%02x] Stream ID=%RU8, channel=%RU8\n",
    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  */
    1704 static 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  */
    1729 static 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  */
    1752 static 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  */
    1773 static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1774 {
    1775     RT_NOREF(pThisCC);
    1776     *pResp = 0;
     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 */
     1703static 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 */
     1728static 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 */
     1751static 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 */
     1772static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1773{
     1774    RT_NOREF(pThisCC);
     1775    *puResp = 0;
    17771776
    17781777    uint32_t *pu32Reg = NULL;
    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));
     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));
    17871786
    17881787    if (pu32Reg)
    1789         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    1790 
    1791     return VINF_SUCCESS;
    1792 }
    1793 
    1794 
    1795 /**
    1796  * @interface_method_impl{CODECVERB, pfn, f0f}
    1797  */
    1798 static 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  */
    1815 static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1816 {
    1817     RT_NOREF(pThisCC);
    1818     *pResp = 0;
     1788        hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
     1789
     1790    return VINF_SUCCESS;
     1791}
     1792
     1793
     1794/**
     1795 * @interface_method_impl{CODECVERB,pfn, f0f}
     1796 */
     1797static 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 */
     1814static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1815{
     1816    RT_NOREF(pThisCC);
     1817    *puResp = 0;
    18191818
    18201819    uint32_t *pu32Reg = NULL;
    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));
     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));
    18251824
    18261825    if (pu32Reg)
    1827         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    1828 
    1829     return VINF_SUCCESS;
    1830 }
    1831 
    1832 
    1833 /**
    1834  * @interface_method_impl{CODECVERB, pfn, f15}
    1835  */
    1836 static 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  */
    1847 static 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  */
    1858 static 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  */
    1869 static 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  */
    1880 static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1881 {
    1882     RT_NOREF(pThisCC);
    1883     *pResp = 0;
     1826        hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
     1827
     1828    return VINF_SUCCESS;
     1829}
     1830
     1831
     1832/**
     1833 * @interface_method_impl{CODECVERB,pfn, f15}
     1834 */
     1835static 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 */
     1846static 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 */
     1857static 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 */
     1868static 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 */
     1879static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1880{
     1881    RT_NOREF(pThisCC);
     1882    *puResp = 0;
    18841883
    18851884    /* Note: this is true for ALC885. */
    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  */
    1898 static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    1899 {
    1900     RT_NOREF(pThisCC);
    1901     *pResp = 0;
     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 */
     1897static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     1898{
     1899    RT_NOREF(pThisCC);
     1900    *puResp = 0;
    19021901
    19031902    uint32_t *pu32Reg = NULL;
    1904     if (CODEC_NID(cmd) == STAC9220_NID_AFG)
     1903    if (CODEC_NID(uCmd) == STAC9220_NID_AFG)
    19051904        pu32Reg = &pThis->aNodes[1].afg.u32F17_param;
    19061905    else
    1907         LogRel2(("HDA: Warning: Unhandled set GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     1906        LogRel2(("HDA: Warning: Unhandled set GPIO direction command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    19081907
    19091908    if (pu32Reg)
    1910         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    1911 
    1912     return VINF_SUCCESS;
    1913 }
    1914 
    1915 
    1916 /**
    1917  * @interface_method_impl{CODECVERB, pfn, f1c}
    1918  */
    1919 static 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 
    1942 static int codecSetConfigX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
     1909        hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
     1910
     1911    return VINF_SUCCESS;
     1912}
     1913
     1914
     1915/**
     1916 * @interface_method_impl{CODECVERB,pfn, f1c}
     1917 */
     1918static 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
     1941static int codecSetConfigX(PHDACODEC pThis, uint32_t uCmd, uint8_t u8Offset)
    19431942{
    19441943    uint32_t *pu32Reg = NULL;
    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));
     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));
    19591958
    19601959    if (pu32Reg)
    1961         hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
    1962 
    1963     return VINF_SUCCESS;
    1964 }
    1965 
    1966 
    1967 /**
    1968  * @interface_method_impl{CODECVERB, pfn, 71c}
    1969  */
    1970 static 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  */
    1981 static 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  */
    1992 static 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  */
    2003 static 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  */
    2014 static 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  */
    2031 static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    2032 {
    2033     RT_NOREF(pThisCC);
    2034     *pResp = 0;
     1960        hdaCodecSetRegisterU8(pu32Reg, uCmd, u8Offset);
     1961
     1962    return VINF_SUCCESS;
     1963}
     1964
     1965
     1966/**
     1967 * @interface_method_impl{CODECVERB,pfn, 71c}
     1968 */
     1969static 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 */
     1980static 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 */
     1991static 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 */
     2002static 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 */
     2013static 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 */
     2030static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     2031{
     2032    RT_NOREF(pThisCC);
     2033    *puResp = 0;
    20352034
    20362035    uint32_t *pu32Reg = NULL;
    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));
     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));
    20412040
    20422041    if (pu32Reg)
    2043         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     2042        hdaCodecSetRegisterU8(pu32Reg, uCmd, 0);
    20442043
    20452044    return VINF_SUCCESS;
    … …  
    20492048
    20502049/**
    2051  * @interface_method_impl{CODECVERB, pfn, 3--}
    2052  */
    2053 static 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)];
     2050 * @interface_method_impl{CODECVERB,pfn, 3--}
     2051 */
     2052static 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)];
    20582057    AMPLIFIER *pAmplifier = NULL;
    2059     if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
     2058    if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
    20602059        pAmplifier = &pNode->dac.B_params;
    2061     else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
     2060    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(uCmd)))
    20622061        pAmplifier = &pNode->adcvol.B_params;
    2063     else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
     2062    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(uCmd)))
    20642063        pAmplifier = &pNode->adcmux.B_params;
    2065     else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
     2064    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(uCmd)))
    20662065        pAmplifier = &pNode->pcbeep.B_params;
    2067     else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
     2066    else if (hdaCodecIsPortNode(pThis, CODEC_NID(uCmd)))
    20682067        pAmplifier = &pNode->port.B_params;
    2069     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
     2068    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
    20702069        pAmplifier = &pNode->adc.B_params;
    20712070    else
    20722071        LogRel2(("HDA: Warning: Unhandled set amplifier command: 0x%x (Payload=%RU16, NID=0x%x [%RU8])\n",
    2073                  cmd, CODEC_VERB_PAYLOAD16(cmd), CODEC_NID(cmd), CODEC_NID(cmd)));
     2072                 uCmd, CODEC_VERB_PAYLOAD16(uCmd), CODEC_NID(uCmd), CODEC_NID(uCmd)));
    20742073
    20752074    if (!pAmplifier)
    20762075        return VINF_SUCCESS;
    20772076
    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);
     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);
    20832082
    20842083    if (   (!fIsLeft && !fIsRight)
    … …  
    20872086
    20882087    LogFunc(("[NID0x%02x] fIsOut=%RTbool, fIsIn=%RTbool, fIsLeft=%RTbool, fIsRight=%RTbool, Idx=%RU8\n",
    2089              CODEC_NID(cmd), fIsOut, fIsIn, fIsLeft, fIsRight, u8Index));
     2088             CODEC_NID(uCmd), fIsOut, fIsIn, fIsLeft, fIsRight, u8Index));
    20902089
    20912090    if (fIsIn)
    20922091    {
    20932092        if (fIsLeft)
    2094             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
     2093            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), uCmd, 0);
    20952094        if (fIsRight)
    2096             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    2097 
    2098     //    if (CODEC_NID(cmd) == pThis->u8AdcVolsLineIn)
     2095            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
     2096
     2097    //    if (CODEC_NID(uCmd) == pThis->u8AdcVolsLineIn)
    20992098    //    {
    21002099            hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_LINE_IN);
    … …  
    21042103    {
    21052104        if (fIsLeft)
    2106             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
     2105            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), uCmd, 0);
    21072106        if (fIsRight)
    2108             hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    2109 
    2110         if (CODEC_NID(cmd) == pThis->u8DacLineOut)
     2107            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
     2108
     2109        if (CODEC_NID(uCmd) == pThis->u8DacLineOut)
    21112110            hdaR3CodecToAudVolume(pThisCC, pNode, pAmplifier, PDMAUDIOMIXERCTL_FRONT);
    21122111    }
    … …  
    21172116
    21182117/**
    2119  * @interface_method_impl{CODECVERB, pfn, 706}
    2120  */
    2121 static 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);
     2118 * @interface_method_impl{CODECVERB,pfn, 706}
     2119 */
     2120static 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);
    21272126
    21282127    LogFlowFunc(("[NID0x%02x] Setting to stream ID=%RU8, channel=%RU8\n",
    2129                  CODEC_NID(cmd), uSD, uChannel));
     2128                 CODEC_NID(uCmd), uSD, uChannel));
    21302129
    21312130    ASSERT_GUEST_LOGREL_MSG_RETURN(uSD < HDA_MAX_STREAMS,
    … …  
    21342133    PDMAUDIODIR enmDir;
    21352134    uint32_t   *pu32Addr;
    2136     if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
    2137     {
    2138         pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].dac.u32F06_param;
     2135    if (hdaCodecIsDacNode(pThis, CODEC_NID(uCmd)))
     2136    {
     2137        pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].dac.u32F06_param;
    21392138        enmDir = PDMAUDIODIR_OUT;
    21402139    }
    2141     else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
    2142     {
    2143         pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].adc.u32F06_param;
     2140    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(uCmd)))
     2141    {
     2142        pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].adc.u32F06_param;
    21442143        enmDir = PDMAUDIODIR_IN;
    21452144    }
    2146     else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
    2147     {
    2148         pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
     2145    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(uCmd)))
     2146    {
     2147        pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].spdifout.u32F06_param;
    21492148        enmDir = PDMAUDIODIR_OUT;
    21502149    }
    2151     else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
    2152     {
    2153         pu32Addr = &pThis->aNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
     2150    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(uCmd)))
     2151    {
     2152        pu32Addr = &pThis->aNodes[CODEC_NID(uCmd)].spdifin.u32F06_param;
    21542153        enmDir = PDMAUDIODIR_IN;
    21552154    }
    … …  
    21572156    {
    21582157        enmDir = PDMAUDIODIR_UNKNOWN;
    2159         LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(cmd), cmd));
     2158        LogRel2(("HDA: Warning: Unhandled set stream ID command for NID0x%02x: 0x%x\n", CODEC_NID(uCmd), uCmd));
    21602159        return VINF_SUCCESS;
    21612160    }
    21622161
    21632162    /* Do we (re-)assign our input/output SDn (SDI/SDO) IDs? */
    2164     pThis->aNodes[CODEC_NID(cmd)].node.uSD      = uSD;
    2165     pThis->aNodes[CODEC_NID(cmd)].node.uChannel = uChannel;
     2163    pThis->aNodes[CODEC_NID(uCmd)].node.uSD      = uSD;
     2164    pThis->aNodes[CODEC_NID(uCmd)].node.uChannel = uChannel;
    21662165
    21672166    if (enmDir == PDMAUDIODIR_OUT)
    … …  
    21842183    }
    21852184
    2186     hdaCodecSetRegisterU8(pu32Addr, cmd, 0);
     2185    hdaCodecSetRegisterU8(pu32Addr, uCmd, 0);
    21872186
    21882187    return VINF_SUCCESS;
    … …  
    22522251
    22532252/**
    2254  * Implements
     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).
    22552257 */
    22562258static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)

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

    r90121 r90122  
    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