Changeset 44668 in vbox for trunk/src/VBox/Devices

Timestamp:

Feb 13, 2013 2:53:36 PM (12 years ago)

Author:

vboxsync

Message:

DevCodec.*: More cleanups... moving all the unnecesary defines from the header to the implementation. Use pThis instead of pState and pCodecState, with a couple of exceptions. Assert() does NOT need double parentheses. Just AssertFailedReturn() if you cannot resolve the input into a register (or whatever), shorter+faster than initializing the register point to NULL and check if it's still NULL after the resolver code.

Location:

trunk/src/VBox/Devices/Audio

Files:

• DevCodec.cpp (modified) (51 diffs)
• DevCodec.h (modified) (5 diffs)
• DevIchIntelHDA.cpp (modified) (6 diffs)

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

@@ -38 +38 @@
 }
 #include "DevCodec.h"
+
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/* PRM 5.3.1 */
+#define CODEC_CAD_MASK              0xF0000000
+#define CODEC_CAD_SHIFT             28
+#define CODEC_DIRECT_MASK           RT_BIT(27)
+#define CODEC_NID_MASK              0x07F00000
+#define CODEC_NID_SHIFT             20
+#define CODEC_VERBDATA_MASK         0x000FFFFF
+#define CODEC_VERB_4BIT_CMD         0x000FFFF0
+#define CODEC_VERB_4BIT_DATA        0x0000000F
+#define CODEC_VERB_8BIT_CMD         0x000FFF00
+#define CODEC_VERB_8BIT_DATA        0x000000FF
+#define CODEC_VERB_16BIT_CMD        0x000F0000
+#define CODEC_VERB_16BIT_DATA       0x0000FFFF
+
+#define CODEC_CAD(cmd) ((cmd) & CODEC_CAD_MASK)
+#define CODEC_DIRECT(cmd) ((cmd) & CODEC_DIRECT_MASK)
+#define CODEC_NID(cmd) ((((cmd) & CODEC_NID_MASK)) >> CODEC_NID_SHIFT)
+#define CODEC_VERBDATA(cmd) ((cmd) & CODEC_VERBDATA_MASK)
+#define CODEC_VERB_CMD(cmd, mask, x) (((cmd) & (mask)) >> (x))
+#define CODEC_VERB_CMD4(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_4BIT_CMD, 4))
+#define CODEC_VERB_CMD8(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_8BIT_CMD, 8))
+#define CODEC_VERB_CMD16(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_16BIT_CMD, 16))
+#define CODEC_VERB_PAYLOAD4(cmd) ((cmd) & CODEC_VERB_4BIT_DATA)
+#define CODEC_VERB_PAYLOAD8(cmd) ((cmd) & CODEC_VERB_8BIT_DATA)
+#define CODEC_VERB_PAYLOAD16(cmd) ((cmd) & CODEC_VERB_16BIT_DATA)
+
+#define CODEC_VERB_GET_AMP_DIRECTION  RT_BIT(15)
+#define CODEC_VERB_GET_AMP_SIDE       RT_BIT(13)
+#define CODEC_VERB_GET_AMP_INDEX      0x7
+
+/* HDA spec 7.3.3.7 NoteA */
+#define CODEC_GET_AMP_DIRECTION(cmd)  (((cmd) & CODEC_VERB_GET_AMP_DIRECTION) >> 15)
+#define CODEC_GET_AMP_SIDE(cmd)       (((cmd) & CODEC_VERB_GET_AMP_SIDE) >> 13)
+#define CODEC_GET_AMP_INDEX(cmd)      (CODEC_GET_AMP_DIRECTION(cmd) ? 0 : ((cmd) & CODEC_VERB_GET_AMP_INDEX))
+
+/* HDA spec 7.3.3.7 NoteC */
+#define CODEC_VERB_SET_AMP_OUT_DIRECTION  RT_BIT(15)
+#define CODEC_VERB_SET_AMP_IN_DIRECTION   RT_BIT(14)
+#define CODEC_VERB_SET_AMP_LEFT_SIDE      RT_BIT(13)
+#define CODEC_VERB_SET_AMP_RIGHT_SIDE     RT_BIT(12)
+#define CODEC_VERB_SET_AMP_INDEX          (0x7 << 8)
+
+#define CODEC_SET_AMP_IS_OUT_DIRECTION(cmd)  (((cmd) & CODEC_VERB_SET_AMP_OUT_DIRECTION) != 0)
+#define CODEC_SET_AMP_IS_IN_DIRECTION(cmd)   (((cmd) & CODEC_VERB_SET_AMP_IN_DIRECTION) != 0)
+#define CODEC_SET_AMP_IS_LEFT_SIDE(cmd)      (((cmd) & CODEC_VERB_SET_AMP_LEFT_SIDE) != 0)
+#define CODEC_SET_AMP_IS_RIGHT_SIDE(cmd)     (((cmd) & CODEC_VERB_SET_AMP_RIGHT_SIDE) != 0)
+#define CODEC_SET_AMP_INDEX(cmd)             (((cmd) & CODEC_VERB_SET_AMP_INDEX) >> 7)
+
+/* HDA spec 7.3.3.1 defines layout of configuration registers/verbs (0xF00) */
+/* VendorID (7.3.4.1) */
+#define CODEC_MAKE_F00_00(vendorID, deviceID) (((vendorID) << 16) | (deviceID))
+#define CODEC_F00_00_VENDORID(f00_00) (((f00_00) >> 16) & 0xFFFF)
+#define CODEC_F00_00_DEVICEID(f00_00) ((f00_00) & 0xFFFF)
+/* RevisionID (7.3.4.2)*/
+#define CODEC_MAKE_F00_02(MajRev, MinRev, RevisionID, SteppingID) (((MajRev) << 20)|((MinRev) << 16)|((RevisionID) << 8)|(SteppingID))
+/* Subordinate node count (7.3.4.3)*/
+#define CODEC_MAKE_F00_04(startNodeNumber, totalNodeNumber) ((((startNodeNumber) & 0xFF) << 16)|((totalNodeNumber) & 0xFF))
+#define CODEC_F00_04_TO_START_NODE_NUMBER(f00_04) (((f00_04) >> 16) & 0xFF)
+#define CODEC_F00_04_TO_NODE_COUNT(f00_04) ((f00_04) & 0xFF)
+/*
+ * Function Group Type  (7.3.4.4)
+ * 0 & [0x3-0x7f] are reserved types
+ * [0x80 - 0xff] are vendor defined function groups
+ */
+#define CODEC_MAKE_F00_05(UnSol, NodeType) (((UnSol) << 8)|(NodeType))
+#define CODEC_F00_05_UNSOL  RT_BIT(8)
+#define CODEC_F00_05_AFG    (0x1)
+#define CODEC_F00_05_MFG    (0x2)
+#define CODEC_F00_05_IS_UNSOL(f00_05) RT_BOOL((f00_05) & RT_BIT(8))
+#define CODEC_F00_05_GROUP(f00_05) ((f00_05) & 0xff)
+/*  Audio Function Group capabilities (7.3.4.5) */
+#define CODEC_MAKE_F00_08(BeepGen, InputDelay, OutputDelay) ((((BeepGen) & 0x1) << 16)| (((InputDelay) & 0xF) << 8) | ((OutputDelay) & 0xF))
+#define CODEC_F00_08_BEEP_GEN(f00_08) ((f00_08) & RT_BIT(16)
+
+/* Widget Capabilities (7.3.4.6) */
+#define CODEC_MAKE_F00_09(type, delay, chanel_count) \
+    ( (((type) & 0xF) << 20)            \
+    | (((delay) & 0xF) << 16)           \
+    | (((chanel_count) & 0xF) << 13))
+/* note: types 0x8-0xe are reserved */
+#define CODEC_F00_09_TYPE_AUDIO_OUTPUT      (0x0)
+#define CODEC_F00_09_TYPE_AUDIO_INPUT       (0x1)
+#define CODEC_F00_09_TYPE_AUDIO_MIXER       (0x2)
+#define CODEC_F00_09_TYPE_AUDIO_SELECTOR    (0x3)
+#define CODEC_F00_09_TYPE_PIN_COMPLEX       (0x4)
+#define CODEC_F00_09_TYPE_POWER_WIDGET      (0x5)
+#define CODEC_F00_09_TYPE_VOLUME_KNOB       (0x6)
+#define CODEC_F00_09_TYPE_BEEP_GEN          (0x7)
+#define CODEC_F00_09_TYPE_VENDOR_DEFINED    (0xF)
+
+#define CODEC_F00_09_CAP_CP                 RT_BIT(12)
+#define CODEC_F00_09_CAP_L_R_SWAP           RT_BIT(11)
+#define CODEC_F00_09_CAP_POWER_CTRL         RT_BIT(10)
+#define CODEC_F00_09_CAP_DIGITAL            RT_BIT(9)
+#define CODEC_F00_09_CAP_CONNECTION_LIST    RT_BIT(8)
+#define CODEC_F00_09_CAP_UNSOL              RT_BIT(7)
+#define CODEC_F00_09_CAP_PROC_WIDGET        RT_BIT(6)
+#define CODEC_F00_09_CAP_STRIPE             RT_BIT(5)
+#define CODEC_F00_09_CAP_FMT_OVERRIDE       RT_BIT(4)
+#define CODEC_F00_09_CAP_AMP_FMT_OVERRIDE   RT_BIT(3)
+#define CODEC_F00_09_CAP_OUT_AMP_PRESENT    RT_BIT(2)
+#define CODEC_F00_09_CAP_IN_AMP_PRESENT     RT_BIT(1)
+#define CODEC_F00_09_CAP_LSB                RT_BIT(0)
+
+#define CODEC_F00_09_TYPE(f00_09) (((f00_09) >> 20) & 0xF)
+
+#define CODEC_F00_09_IS_CAP_CP(f00_09)              RT_BOOL((f00_09) & RT_BIT(12))
+#define CODEC_F00_09_IS_CAP_L_R_SWAP(f00_09)        RT_BOOL((f00_09) & RT_BIT(11))
+#define CODEC_F00_09_IS_CAP_POWER_CTRL(f00_09)      RT_BOOL((f00_09) & RT_BIT(10))
+#define CODEC_F00_09_IS_CAP_DIGITAL(f00_09)         RT_BOOL((f00_09) & RT_BIT(9))
+#define CODEC_F00_09_IS_CAP_CONNECTION_LIST(f00_09) RT_BOOL((f00_09) & RT_BIT(8))
+#define CODEC_F00_09_IS_CAP_UNSOL(f00_09)           RT_BOOL((f00_09) & RT_BIT(7))
+#define CODEC_F00_09_IS_CAP_PROC_WIDGET(f00_09)     RT_BOOL((f00_09) & RT_BIT(6))
+#define CODEC_F00_09_IS_CAP_STRIPE(f00_09)          RT_BOOL((f00_09) & RT_BIT(5))
+#define CODEC_F00_09_IS_CAP_FMT_OVERRIDE(f00_09)    RT_BOOL((f00_09) & RT_BIT(4))
+#define CODEC_F00_09_IS_CAP_AMP_OVERRIDE(f00_09)    RT_BOOL((f00_09) & RT_BIT(3))
+#define CODEC_F00_09_IS_CAP_OUT_AMP_PRESENT(f00_09) RT_BOOL((f00_09) & RT_BIT(2))
+#define CODEC_F00_09_IS_CAP_IN_AMP_PRESENT(f00_09)  RT_BOOL((f00_09) & RT_BIT(1))
+#define CODEC_F00_09_IS_CAP_LSB(f00_09)             RT_BOOL((f00_09) & RT_BIT(0))
+
+/* Supported PCM size, rates (7.3.4.7) */
+#define CODEC_F00_0A_32_BIT             RT_BIT(19)
+#define CODEC_F00_0A_24_BIT             RT_BIT(18)
+#define CODEC_F00_0A_16_BIT             RT_BIT(17)
+#define CODEC_F00_0A_8_BIT              RT_BIT(16)
+
+#define CODEC_F00_0A_48KHZ_MULT_8X      RT_BIT(11)
+#define CODEC_F00_0A_48KHZ_MULT_4X      RT_BIT(10)
+#define CODEC_F00_0A_44_1KHZ_MULT_4X    RT_BIT(9)
+#define CODEC_F00_0A_48KHZ_MULT_2X      RT_BIT(8)
+#define CODEC_F00_0A_44_1KHZ_MULT_2X    RT_BIT(7)
+#define CODEC_F00_0A_48KHZ              RT_BIT(6)
+#define CODEC_F00_0A_44_1KHZ            RT_BIT(5)
+/* 2/3 * 48kHz */
+#define CODEC_F00_0A_48KHZ_2_3X         RT_BIT(4)
+/* 1/2 * 44.1kHz */
+#define CODEC_F00_0A_44_1KHZ_1_2X       RT_BIT(3)
+/* 1/3 * 48kHz */
+#define CODEC_F00_0A_48KHZ_1_3X         RT_BIT(2)
+/* 1/4 * 44.1kHz */
+#define CODEC_F00_0A_44_1KHZ_1_4X       RT_BIT(1)
+/* 1/6 * 48kHz */
+#define CODEC_F00_0A_48KHZ_1_6X         RT_BIT(0)
+
+/* Supported streams formats (7.3.4.8) */
+#define CODEC_F00_0B_AC3                RT_BIT(2)
+#define CODEC_F00_0B_FLOAT32            RT_BIT(1)
+#define CODEC_F00_0B_PCM                RT_BIT(0)
+
+/* Pin Capabilities (7.3.4.9)*/
+#define CODEC_MAKE_F00_0C(vref_ctrl) (((vref_ctrl) & 0xFF) << 8)
+#define CODEC_F00_0C_CAP_HBR                    RT_BIT(27)
+#define CODEC_F00_0C_CAP_DP                     RT_BIT(24)
+#define CODEC_F00_0C_CAP_EAPD                   RT_BIT(16)
+#define CODEC_F00_0C_CAP_HDMI                   RT_BIT(7)
+#define CODEC_F00_0C_CAP_BALANCED_IO            RT_BIT(6)
+#define CODEC_F00_0C_CAP_INPUT                  RT_BIT(5)
+#define CODEC_F00_0C_CAP_OUTPUT                 RT_BIT(4)
+#define CODEC_F00_0C_CAP_HP                     RT_BIT(3)
+#define CODEC_F00_0C_CAP_PRESENSE_DETECT        RT_BIT(2)
+#define CODEC_F00_0C_CAP_TRIGGER_REQUIRED       RT_BIT(1)
+#define CODEC_F00_0C_CAP_IMPENDANCE_SENSE       RT_BIT(0)
+
+#define CODEC_F00_0C_IS_CAP_HBR(f00_0c)                    ((f00_0c) & RT_BIT(27))
+#define CODEC_F00_0C_IS_CAP_DP(f00_0c)                     ((f00_0c) & RT_BIT(24))
+#define CODEC_F00_0C_IS_CAP_EAPD(f00_0c)                   ((f00_0c) & RT_BIT(16))
+#define CODEC_F00_0C_IS_CAP_HDMI(f00_0c)                   ((f00_0c) & RT_BIT(7))
+#define CODEC_F00_0C_IS_CAP_BALANCED_IO(f00_0c)            ((f00_0c) & RT_BIT(6))
+#define CODEC_F00_0C_IS_CAP_INPUT(f00_0c)                  ((f00_0c) & RT_BIT(5))
+#define CODEC_F00_0C_IS_CAP_OUTPUT(f00_0c)                 ((f00_0c) & RT_BIT(4))
+#define CODEC_F00_0C_IS_CAP_HP(f00_0c)                     ((f00_0c) & RT_BIT(3))
+#define CODEC_F00_0C_IS_CAP_PRESENSE_DETECT(f00_0c)        ((f00_0c) & RT_BIT(2))
+#define CODEC_F00_0C_IS_CAP_TRIGGER_REQUIRED(f00_0c)       ((f00_0c) & RT_BIT(1))
+#define CODEC_F00_0C_IS_CAP_IMPENDANCE_SENSE(f00_0c)       ((f00_0c) & RT_BIT(0))
+
+/* Input Amplifier capabilities (7.3.4.10) */
+#define CODEC_MAKE_F00_0D(mute_cap, step_size, num_steps, offset) \
+        (  (((mute_cap) & 0x1) << 31)                             \
+         | (((step_size) & 0xFF) << 16)                           \
+         | (((num_steps) & 0xFF) << 8)                            \
+         | ((offset) & 0xFF))
+
+/* Output Amplifier capabilities (7.3.4.10) */
+#define CODEC_MAKE_F00_12 CODEC_MAKE_F00_0D
+
+/* Connection list lenght (7.3.4.11) */
+#define CODEC_MAKE_F00_0E(long_form, length)    \
+    (  (((long_form) & 0x1) << 7)               \
+     | ((length) & 0x7F))
+#define CODEC_F00_0E_IS_LONG(f00_0e) RT_BOOL((f00_0e) & RT_BIT(7))
+#define CODEC_F00_0E_COUNT(f00_0e) ((f00_0e) & 0x7F)
+/* Supported Power States (7.3.4.12) */
+#define CODEC_F00_0F_EPSS       RT_BIT(31)
+#define CODEC_F00_0F_CLKSTOP    RT_BIT(30)
+#define CODEC_F00_0F_S3D3       RT_BIT(29)
+#define CODEC_F00_0F_D3COLD     RT_BIT(4)
+#define CODEC_F00_0F_D3         RT_BIT(3)
+#define CODEC_F00_0F_D2         RT_BIT(2)
+#define CODEC_F00_0F_D1         RT_BIT(1)
+#define CODEC_F00_0F_D0         RT_BIT(0)
+
+/* Processing capabilities 7.3.4.13 */
+#define CODEC_MAKE_F00_10(num, benign) ((((num) & 0xFF) << 8) | ((benign) & 0x1))
+#define CODEC_F00_10_NUM(f00_10) (((f00_10) & (0xFF << 8)) >> 8)
+#define CODEC_F00_10_BENING(f00_10) ((f00_10) & 0x1)
+
+/* CP/IO Count (7.3.4.14) */
+#define CODEC_MAKE_F00_11(wake, unsol, numgpi, numgpo, numgpio) \
+    (  (((wake) & 0x1) << 31)                                   \
+     | (((unsol) & 0x1) << 30)                                  \
+     | (((numgpi) & 0xFF) << 16)                                \
+     | (((numgpo) & 0xFF) << 8)                                 \
+     | ((numgpio) & 0xFF))
+
+/* Processing States (7.3.3.4) */
+#define CODEC_F03_OFF    (0)
+#define CODEC_F03_ON     RT_BIT(0)
+#define CODEC_F03_BENING RT_BIT(1)
+/* Power States (7.3.3.10) */
+#define CODEC_MAKE_F05(reset, stopok, error, act, set)          \
+    (   (((reset) & 0x1) << 10)                                 \
+      | (((stopok) & 0x1) << 9)                                 \
+      | (((error) & 0x1) << 8)                                  \
+      | (((act) & 0x7) << 4)                                    \
+      | ((set) & 0x7))
+#define CODEC_F05_D3COLD    (4)
+#define CODEC_F05_D3        (3)
+#define CODEC_F05_D2        (2)
+#define CODEC_F05_D1        (1)
+#define CODEC_F05_D0        (0)
+
+#define CODEC_F05_IS_RESET(value)   (((value) & RT_BIT(10)) != 0)
+#define CODEC_F05_IS_STOPOK(value)  (((value) & RT_BIT(9)) != 0)
+#define CODEC_F05_IS_ERROR(value)   (((value) & RT_BIT(8)) != 0)
+#define CODEC_F05_ACT(value)        (((value) & 0x7) >> 4)
+#define CODEC_F05_SET(value)        (((value) & 0x7))
+
+#define CODEC_F05_GE(p0, p1) ((p0) <= (p1))
+#define CODEC_F05_LE(p0, p1) ((p0) >= (p1))
+
+/* Pin Widged Control (7.3.3.13) */
+#define CODEC_F07_VREF_HIZ      (0)
+#define CODEC_F07_VREF_50       (0x1)
+#define CODEC_F07_VREF_GROUND   (0x2)
+#define CODEC_F07_VREF_80       (0x4)
+#define CODEC_F07_VREF_100      (0x5)
+#define CODEC_F07_IN_ENABLE     RT_BIT(5)
+#define CODEC_F07_OUT_ENABLE    RT_BIT(6)
+#define CODEC_F07_OUT_H_ENABLE  RT_BIT(7)
+
+/* Unsolicited enabled (7.3.3.14) */
+#define CODEC_MAKE_F08(enable, tag) ((((enable) & 1) << 7) | ((tag) & 0x3F))
+
+/* Converter formats (7.3.3.8) and (3.7.1) */
+#define CODEC_MAKE_A(fNonPCM, f44_1BaseRate, mult, div, bits, chan) \
+    (  (((fNonPCM) & 0x1) << 15)                                    \
+     | (((f44_1BaseRate) & 0x1) << 14)                              \
+     | (((mult) & 0x7) << 11)                                       \
+     | (((div) & 0x7) << 8)                                         \
+     | (((bits) & 0x7) << 4)                                        \
+     | ((chan) & 0xF))
+
+#define CODEC_A_MULT_1X     (0)
+#define CODEC_A_MULT_2X     (1)
+#define CODEC_A_MULT_3X     (2)
+#define CODEC_A_MULT_4X     (3)
+
+#define CODEC_A_DIV_1X      (0)
+#define CODEC_A_DIV_2X      (1)
+#define CODEC_A_DIV_3X      (2)
+#define CODEC_A_DIV_4X      (3)
+#define CODEC_A_DIV_5X      (4)
+#define CODEC_A_DIV_6X      (5)
+#define CODEC_A_DIV_7X      (6)
+#define CODEC_A_DIV_8X      (7)
+
+#define CODEC_A_8_BIT       (0)
+#define CODEC_A_16_BIT      (1)
+#define CODEC_A_20_BIT      (2)
+#define CODEC_A_24_BIT      (3)
+#define CODEC_A_32_BIT      (4)
+
+/* Pin Sense (7.3.3.15) */
+#define CODEC_MAKE_F09_ANALOG(fPresent, impedance)  \
+(  (((fPresent) & 0x1) << 31)                       \
+ | (((impedance) & 0x7FFFFFFF)))
+#define CODEC_F09_ANALOG_NA    0x7FFFFFFF
+#define CODEC_MAKE_F09_DIGITAL(fPresent, fELDValid) \
+(   (((fPresent) & 0x1) << 31)                      \
+  | (((fELDValid) & 0x1) << 30))
+
+#define CODEC_MAKE_F0C(lrswap, eapd, btl) ((((lrswap) & 1) << 2) | (((eapd) & 1) << 1) | ((btl) & 1))
+#define CODEC_FOC_IS_LRSWAP(f0c)    RT_BOOL((f0c) & RT_BIT(2))
+#define CODEC_FOC_IS_EAPD(f0c)      RT_BOOL((f0c) & RT_BIT(1))
+#define CODEC_FOC_IS_BTL(f0c)       RT_BOOL((f0c) & RT_BIT(0))
+/* HDA spec 7.3.3.31 defines layout of configuration registers/verbs (0xF1C) */
+/* Configuration's port connection */
+#define CODEC_F1C_PORT_MASK    (0x3)
+#define CODEC_F1C_PORT_SHIFT   (30)
+
+#define CODEC_F1C_PORT_COMPLEX (0x0)
+#define CODEC_F1C_PORT_NO_PHYS (0x1)
+#define CODEC_F1C_PORT_FIXED   (0x2)
+#define CODEC_F1C_BOTH         (0x3)
+
+/* Configuration's location */
+#define CODEC_F1C_LOCATION_MASK  (0x3F)
+#define CODEC_F1C_LOCATION_SHIFT (24)
+/* [4:5] bits of location region means chassis attachment */
+#define CODEC_F1C_LOCATION_PRIMARY_CHASSIS     (0)
+#define CODEC_F1C_LOCATION_INTERNAL            RT_BIT(4)
+#define CODEC_F1C_LOCATION_SECONDRARY_CHASSIS  RT_BIT(5)
+#define CODEC_F1C_LOCATION_OTHER               (RT_BIT(5))
+
+/* [0:3] bits of location region means geometry location attachment */
+#define CODEC_F1C_LOCATION_NA                  (0)
+#define CODEC_F1C_LOCATION_REAR                (0x1)
+#define CODEC_F1C_LOCATION_FRONT               (0x2)
+#define CODEC_F1C_LOCATION_LEFT                (0x3)
+#define CODEC_F1C_LOCATION_RIGTH               (0x4)
+#define CODEC_F1C_LOCATION_TOP                 (0x5)
+#define CODEC_F1C_LOCATION_BOTTOM              (0x6)
+#define CODEC_F1C_LOCATION_SPECIAL_0           (0x7)
+#define CODEC_F1C_LOCATION_SPECIAL_1           (0x8)
+#define CODEC_F1C_LOCATION_SPECIAL_2           (0x9)
+
+/* Configuration's devices */
+#define CODEC_F1C_DEVICE_MASK                  (0xF)
+#define CODEC_F1C_DEVICE_SHIFT                 (20)
+#define CODEC_F1C_DEVICE_LINE_OUT              (0)
+#define CODEC_F1C_DEVICE_SPEAKER               (0x1)
+#define CODEC_F1C_DEVICE_HP                    (0x2)
+#define CODEC_F1C_DEVICE_CD                    (0x3)
+#define CODEC_F1C_DEVICE_SPDIF_OUT             (0x4)
+#define CODEC_F1C_DEVICE_DIGITAL_OTHER_OUT     (0x5)
+#define CODEC_F1C_DEVICE_MODEM_LINE_SIDE       (0x6)
+#define CODEC_F1C_DEVICE_MODEM_HANDSET_SIDE    (0x7)
+#define CODEC_F1C_DEVICE_LINE_IN               (0x8)
+#define CODEC_F1C_DEVICE_AUX                   (0x9)
+#define CODEC_F1C_DEVICE_MIC                   (0xA)
+#define CODEC_F1C_DEVICE_PHONE                 (0xB)
+#define CODEC_F1C_DEVICE_SPDIF_IN              (0xC)
+#define CODEC_F1C_DEVICE_RESERVED              (0xE)
+#define CODEC_F1C_DEVICE_OTHER                 (0xF)
+
+/* Configuration's Connection type */
+#define CODEC_F1C_CONNECTION_TYPE_MASK         (0xF)
+#define CODEC_F1C_CONNECTION_TYPE_SHIFT        (16)
+
+#define CODEC_F1C_CONNECTION_TYPE_UNKNOWN               (0)
+#define CODEC_F1C_CONNECTION_TYPE_1_8INCHES             (0x1)
+#define CODEC_F1C_CONNECTION_TYPE_1_4INCHES             (0x2)
+#define CODEC_F1C_CONNECTION_TYPE_ATAPI                 (0x3)
+#define CODEC_F1C_CONNECTION_TYPE_RCA                   (0x4)
+#define CODEC_F1C_CONNECTION_TYPE_OPTICAL               (0x5)
+#define CODEC_F1C_CONNECTION_TYPE_OTHER_DIGITAL         (0x6)
+#define CODEC_F1C_CONNECTION_TYPE_ANALOG                (0x7)
+#define CODEC_F1C_CONNECTION_TYPE_DIN                   (0x8)
+#define CODEC_F1C_CONNECTION_TYPE_XLR                   (0x9)
+#define CODEC_F1C_CONNECTION_TYPE_RJ_11                 (0xA)
+#define CODEC_F1C_CONNECTION_TYPE_COMBO                 (0xB)
+#define CODEC_F1C_CONNECTION_TYPE_OTHER                 (0xF)
+
+/* Configuration's color */
+#define CODEC_F1C_COLOR_MASK                  (0xF)
+#define CODEC_F1C_COLOR_SHIFT                 (12)
+#define CODEC_F1C_COLOR_UNKNOWN               (0)
+#define CODEC_F1C_COLOR_BLACK                 (0x1)
+#define CODEC_F1C_COLOR_GREY                  (0x2)
+#define CODEC_F1C_COLOR_BLUE                  (0x3)
+#define CODEC_F1C_COLOR_GREEN                 (0x4)
+#define CODEC_F1C_COLOR_RED                   (0x5)
+#define CODEC_F1C_COLOR_ORANGE                (0x6)
+#define CODEC_F1C_COLOR_YELLOW                (0x7)
+#define CODEC_F1C_COLOR_PURPLE                (0x8)
+#define CODEC_F1C_COLOR_PINK                  (0x9)
+#define CODEC_F1C_COLOR_RESERVED_0            (0xA)
+#define CODEC_F1C_COLOR_RESERVED_1            (0xB)
+#define CODEC_F1C_COLOR_RESERVED_2            (0xC)
+#define CODEC_F1C_COLOR_RESERVED_3            (0xD)
+#define CODEC_F1C_COLOR_WHITE                 (0xE)
+#define CODEC_F1C_COLOR_OTHER                 (0xF)
+
+/* Configuration's misc */
+#define CODEC_F1C_MISC_MASK                  (0xF)
+#define CODEC_F1C_MISC_SHIFT                 (8)
+#define CODEC_F1C_MISC_JACK_DETECT           (0)
+#define CODEC_F1C_MISC_RESERVED_0            (1)
+#define CODEC_F1C_MISC_RESERVED_1            (2)
+#define CODEC_F1C_MISC_RESERVED_2            (3)
+
+/* Configuration's association */
+#define CODEC_F1C_ASSOCIATION_MASK                  (0xF)
+#define CODEC_F1C_ASSOCIATION_SHIFT                 (4)
+/* Connection's sequence */
+#define CODEC_F1C_SEQ_MASK                  (0xF)
+#define CODEC_F1C_SEQ_SHIFT                 (0)
+
+/* Implementation identification (7.3.3.30) */
+#define CODEC_MAKE_F20(bmid, bsku, aid)     \
+    (  (((bmid) & 0xFFFF) << 16)            \
+     | (((bsku) & 0xFF) << 8)               \
+     | (((aid) & 0xFF))                     \
+    )
+
+/* macro definition helping in filling the configuration registers. */
+#define CODEC_MAKE_F1C(port_connectivity, location, device, connection_type, color, misc, association, sequence)    \
+    (  ((port_connectivity) << CODEC_F1C_PORT_SHIFT)          \
+     | ((location) << CODEC_F1C_LOCATION_SHIFT)               \
+     | ((device) << CODEC_F1C_DEVICE_SHIFT)                   \
+     | ((connection_type) << CODEC_F1C_CONNECTION_TYPE_SHIFT) \
+     | ((color) << CODEC_F1C_COLOR_SHIFT)                     \
+     | ((misc) << CODEC_F1C_MISC_SHIFT)                       \
+     | ((association) << CODEC_F1C_ASSOCIATION_SHIFT)         \
+     | ((sequence)))
 
 
@@ -321 +741 @@
 
 
-/*******************************************************************************
-*   Internal Functions                                                         *
-*******************************************************************************/
-static int stac9220ResetNode(PHDACODEC pState, uint8_t nodenum, PCODECNODE pNode);
-
-
-
-static int stac9220Construct(PHDACODEC pState)
-{
-    unconst(pState->cTotalNodes) = 0x1C;
-    pState->pfnCodecNodeReset = stac9220ResetNode;
-    pState->u16VendorId = 0x8384;
-    pState->u16DeviceId = 0x7680;
-    pState->u8BSKU = 0x76;
-    pState->u8AssemblyId = 0x80;
-    pState->paNodes = (PCODECNODE)RTMemAllocZ(sizeof(CODECNODE) * pState->cTotalNodes);
-    pState->fInReset = false;
-#define STAC9220WIDGET(type) pState->au8##type##s = g_abStac9220##type##s
-    STAC9220WIDGET(Port);
-    STAC9220WIDGET(Dac);
-    STAC9220WIDGET(Adc);
-    STAC9220WIDGET(AdcVol);
-    STAC9220WIDGET(AdcMux);
-    STAC9220WIDGET(Pcbeep);
-    STAC9220WIDGET(SpdifIn);
-    STAC9220WIDGET(SpdifOut);
-    STAC9220WIDGET(DigInPin);
-    STAC9220WIDGET(DigOutPin);
-    STAC9220WIDGET(Cd);
-    STAC9220WIDGET(VolKnob);
-    STAC9220WIDGET(Reserved);
-#undef STAC9220WIDGET
-    unconst(pState->u8AdcVolsLineIn) = 0x17;
-    unconst(pState->u8DacLineOut) = 0x2;
-
-    return VINF_SUCCESS;
-}
-
-static int stac9220ResetNode(PHDACODEC pState, uint8_t nodenum, PCODECNODE pNode)
+
+
+static int stac9220ResetNode(PHDACODEC pThis, uint8_t nodenum, PCODECNODE pNode)
 {
     pNode->node.id = nodenum;
@@ -427 +811 @@
                                                   | CODEC_F00_09_CAP_FMT_OVERRIDE
                                                   | CODEC_F00_09_CAP_LSB;//(4 << 16) | RT_BIT(9)|RT_BIT(4)|0x1;
-            pNode->node.au32F00_param[0xa] = pState->paNodes[1].node.au32F00_param[0xA];
+            pNode->node.au32F00_param[0xa] = pThis->paNodes[1].node.au32F00_param[0xA];
             pNode->spdifout.node.au32F00_param[0xB] = CODEC_F00_0B_PCM;
             pNode->spdifout.u32F06_param = 0;
@@ -439 +823 @@
                                                  | CODEC_F00_09_CAP_FMT_OVERRIDE
                                                  | CODEC_F00_09_CAP_LSB;//(0x1 << 20)|(4 << 16) | RT_BIT(9)| RT_BIT(8)|RT_BIT(4)|0x1;
-            pNode->node.au32F00_param[0xA] = pState->paNodes[1].node.au32F00_param[0xA];
+            pNode->node.au32F00_param[0xA] = pThis->paNodes[1].node.au32F00_param[0xA];
             pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 1);//RT_BIT(0);
             pNode->node.au32F02_param[0] = 0x11;
@@ -458 +842 @@
                                      | CODEC_F07_OUT_ENABLE;
             pNode->port.u32F08_param = 0;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_FRONT,
@@ -476 +860 @@
             pNode->node.au32F02_param[0] = 0x4;
             pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_INTERNAL|CODEC_F1C_LOCATION_REAR,
@@ -494 +878 @@
                                            | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
             pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_REAR,
@@ -511 +895 @@
             pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
             pNode->node.au32F02_param[0] = 0x2;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_FRONT,
@@ -537 +921 @@
             pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
             pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(0, CODEC_F09_ANALOG_NA);//0x7fffffff;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_REAR,
@@ -560 +944 @@
             pNode->port.u32F07_param = CODEC_F07_OUT_ENABLE
                                      | CODEC_F07_IN_ENABLE;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                           CODEC_F1C_LOCATION_INTERNAL,
@@ -578 +962 @@
             pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 0x3);
             pNode->node.au32F02_param[0] = RT_MAKE_U32_FROM_U8(0x08, 0x17, 0x19, 0);
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->digout.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                             CODEC_F1C_LOCATION_REAR,
@@ -596 +980 @@
             pNode->digin.u32F09_param = 0;
             pNode->digin.u32F0c_param = 0;
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->digin.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
                                                            CODEC_F1C_LOCATION_REAR,
@@ -634 +1018 @@
                                            | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(0);
             pNode->node.au32F00_param[0xc] = CODEC_F00_0C_CAP_INPUT;//RT_BIT(5);
-            if (!pState->fInReset)
+            if (!pThis->fInReset)
                 pNode->cdnode.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_FIXED,
                                                             CODEC_F1C_LOCATION_INTERNAL,
@@ -699 +1083 @@
 }
 
-/* generic */
+
+static int stac9220Construct(PHDACODEC pThis)
+{
+    unconst(pThis->cTotalNodes) = 0x1C;
+    pThis->pfnCodecNodeReset = stac9220ResetNode;
+    pThis->u16VendorId = 0x8384;
+    pThis->u16DeviceId = 0x7680;
+    pThis->u8BSKU = 0x76;
+    pThis->u8AssemblyId = 0x80;
+    pThis->paNodes = (PCODECNODE)RTMemAllocZ(sizeof(CODECNODE) * pThis->cTotalNodes);
+    pThis->fInReset = false;
+#define STAC9220WIDGET(type) pThis->au8##type##s = g_abStac9220##type##s
+    STAC9220WIDGET(Port);
+    STAC9220WIDGET(Dac);
+    STAC9220WIDGET(Adc);
+    STAC9220WIDGET(AdcVol);
+    STAC9220WIDGET(AdcMux);
+    STAC9220WIDGET(Pcbeep);
+    STAC9220WIDGET(SpdifIn);
+    STAC9220WIDGET(SpdifOut);
+    STAC9220WIDGET(DigInPin);
+    STAC9220WIDGET(DigOutPin);
+    STAC9220WIDGET(Cd);
+    STAC9220WIDGET(VolKnob);
+    STAC9220WIDGET(Reserved);
+#undef STAC9220WIDGET
+    unconst(pThis->u8AdcVolsLineIn) = 0x17;
+    unconst(pThis->u8DacLineOut) = 0x2;
+
+    return VINF_SUCCESS;
+}
+
+
+/*
+ * Some generic predicate functions.
+ */
 
 #define DECLISNODEOFTYPE(type)                                                                  \
-    DECLINLINE(int) hdaCodecIs##type##Node(PHDACODEC pState, uint8_t cNode)                     \
+    DECLINLINE(int) hdaCodecIs##type##Node(PHDACODEC pThis, uint8_t cNode)                     \
     {                                                                                           \
-        Assert(pState->au8##type##s);                                                           \
-        for (int i = 0; pState->au8##type##s[i] != 0; ++i)                                      \
-            if (pState->au8##type##s[i] == cNode)                                               \
+        Assert(pThis->au8##type##s);                                                           \
+        for (int i = 0; pThis->au8##type##s[i] != 0; ++i)                                      \
+            if (pThis->au8##type##s[i] == cNode)                                               \
                 return 1;                                                                       \
         return 0;                                                                               \
@@ -737 +1156 @@
 DECLISNODEOFTYPE(Reserved)
 
-static int hdaCodecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt);
+
+/*
+ * Misc helpers.
+ */
+
+static int hdaCodecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt)
+{
+    uint32_t dir = AMPLIFIER_OUT;
+    switch (mt)
+    {
+        case AUD_MIXER_VOLUME:
+        case AUD_MIXER_PCM:
+            dir = AMPLIFIER_OUT;
+            break;
+        case AUD_MIXER_LINE_IN:
+            dir = AMPLIFIER_IN;
+            break;
+    }
+    int mute = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & RT_BIT(7);
+    mute |= AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & RT_BIT(7);
+    mute >>=7;
+    mute &= 0x1;
+    uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & 0x7f;
+    uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & 0x7f;
+    AUD_set_volume(mt, &mute, &lVol, &rVol);
+    return VINF_SUCCESS;
+}
 
 DECLINLINE(void) hdaCodecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
@@ -745 +1190 @@
     *pu32Reg |= (u32Cmd & mask) << u8Offset;
 }
+
 DECLINLINE(void) hdaCodecSetRegisterU8(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
 {
@@ -760 +1206 @@
  */
 
-static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
+static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
     Log(("vrbProcUnimplemented: cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
@@ -768 +1214 @@
 }
 
-static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
+static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
 {
     int rc;
-    rc = vrbProcUnimplemented(pState, cmd, pResp);
+    rc = vrbProcUnimplemented(pThis, cmd, pResp);
     *pResp |= CODEC_RESPONSE_UNSOLICITED;
     return rc;
@@ -777 +1223 @@
 
 /* B-- */
-static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -788 +1234 @@
     *pResp = 0;
     /* HDA spec 7.3.3.7 Note A */
-    /* @todo: if index out of range response should be 0 */
+    /** @todo: if index out of range response should be 0 */
     uint8_t u8Index = CODEC_GET_AMP_DIRECTION(cmd) == AMPLIFIER_OUT? 0 : CODEC_GET_AMP_INDEX(cmd);
 
-    PCODECNODE pNode = &pState->paNodes[CODEC_NID(cmd)];
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
+    PCODECNODE pNode = &pThis->paNodes[CODEC_NID(cmd)];
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->port.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
         *pResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
                             CODEC_GET_AMP_DIRECTION(cmd),
                             CODEC_GET_AMP_SIDE(cmd),
                             u8Index);
-    else{
-        AssertMsgReturn(0, ("access to fields of %x need to be implemented\n", CODEC_NID(cmd)), VINF_SUCCESS);
-    }
+    else
+        AssertMsgFailedReturn(("access to fields of %x need to be implemented\n", CODEC_NID(cmd)), VINF_SUCCESS);
     return VINF_SUCCESS;
 }
 
 /* 3-- */
-static DECLCALLBACK(int) vrbProcSetAmplifier(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    AMPLIFIER *pAmplifier = NULL;
+static DECLCALLBACK(int) vrbProcSetAmplifier(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
     bool fIsLeft = false;
     bool fIsRight = false;
@@ -837 +1281 @@
     bool fIsIn = false;
     uint8_t u8Index = 0;
-    Assert((CODEC_CAD(cmd) == pState->id));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    PCODECNODE pNode = &pState->paNodes[CODEC_NID(cmd)];
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    PCODECNODE pNode = &pThis->paNodes[CODEC_NID(cmd)];
+    AMPLIFIER *pAmplifier;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->dac.B_params;
-    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->adcvol.B_params;
-    else if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->adcmux.B_params;
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->pcbeep.B_params;
-    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->port.B_params;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
         pAmplifier = &pNode->adc.B_params;
-    Assert(pAmplifier);
-    if (pAmplifier)
-    {
-        fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
-        fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
-        fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
-        fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
-        u8Index = CODEC_SET_AMP_INDEX(cmd);
-        if (   (!fIsLeft && !fIsRight)
-            || (!fIsOut && !fIsIn))
-            return VINF_SUCCESS;
-        if (fIsIn)
-        {
-            if (fIsLeft)
-                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
-            if (fIsRight)
-                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
-        }
-        if (fIsOut)
-        {
-            if (fIsLeft)
-                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
-            if (fIsRight)
-                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
-        }
-        if (CODEC_NID(cmd) == pState->u8DacLineOut)
-            hdaCodecToAudVolume(pAmplifier, AUD_MIXER_VOLUME);
-        if (CODEC_NID(cmd) == pState->u8AdcVolsLineIn) /* Microphone */
-            hdaCodecToAudVolume(pAmplifier, AUD_MIXER_LINE_IN);
-    }
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert(CODEC_CAD(cmd) == pState->id);
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+
+    fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
+    fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
+    fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
+    fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
+    u8Index = CODEC_SET_AMP_INDEX(cmd);
+    if (   (!fIsLeft && !fIsRight)
+        || (!fIsOut && !fIsIn))
+        return VINF_SUCCESS;
+    if (fIsIn)
+    {
+        if (fIsLeft)
+            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
+        if (fIsRight)
+            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
+    }
+    if (fIsOut)
+    {
+        if (fIsLeft)
+            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
+        if (fIsRight)
+            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
+    }
+    if (CODEC_NID(cmd) == pThis->u8DacLineOut)
+        hdaCodecToAudVolume(pAmplifier, AUD_MIXER_VOLUME);
+    if (CODEC_NID(cmd) == pThis->u8AdcVolsLineIn) /* Microphone */
+        hdaCodecToAudVolume(pAmplifier, AUD_MIXER_LINE_IN);
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -904 +1348 @@
         return VINF_SUCCESS;
     }
-    *pResp = 0;
-    *pResp = pState->paNodes[CODEC_NID(cmd)].node.au32F00_param[cmd & CODEC_VERB_8BIT_DATA];
+    *pResp = pThis->paNodes[CODEC_NID(cmd)].node.au32F00_param[cmd & CODEC_VERB_8BIT_DATA];
     return VINF_SUCCESS;
 }
 
 /* F01 */
-static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert(CODEC_CAD(cmd) == pState->id);
-    Assert(CODEC_NID(cmd) < pState->cTotalNodes);
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
-    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F01_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
-    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
+static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
+    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F01_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
+    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
     return VINF_SUCCESS;
 }
 
 /* 701 */
-static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    uint32_t *pu32Reg = NULL;
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
-    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F01_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
-    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
-    Assert((pu32Reg));
-    if (pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
+    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F01_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
+    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     return VINF_SUCCESS;
 }
 
 /* F07 */
-static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F07_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
-    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
+static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F07_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
+    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
     else
         AssertMsgFailed(("Unsupported"));
@@ -989 +1432 @@
 
 /* 707 */
-static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    uint32_t *pu32Reg = NULL;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F07_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
-    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
-    else if (   hdaCodecIsReservedNode(pState, CODEC_NID(cmd))
+static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F07_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
+    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
+    else if (   hdaCodecIsReservedNode(pThis, CODEC_NID(cmd))
              && CODEC_NID(cmd) == 0x1b)
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
-    Assert((pu32Reg));
-    if (pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     return VINF_SUCCESS;
 }
 
 /* F08 */
-static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F08_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
+static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F08_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
     else if ((cmd) == 1 /* AFG */)
-        *pResp = pState->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
-    else if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
+    else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
     else
         AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
@@ -1048 +1491 @@
 
 /* 708 */
-static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    uint32_t *pu32Reg = NULL;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F08_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
+static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F08_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
     else if (CODEC_NID(cmd) == 1 /* AFG */)
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
-    else if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
+    else if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
+    else
+        AssertMsgFailedReturn(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)), VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+    return VINF_SUCCESS;
+}
+
+/* F09 */
+static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F09_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
     else
         AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
-    Assert(pu32Reg);
-    if(pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
-    return VINF_SUCCESS;
-}
-
-/* F09 */
-static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F09_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
+    return VINF_SUCCESS;
+}
+
+/* 709 */
+static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F09_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
     else
-        AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
-    return VINF_SUCCESS;
-}
-
-/* 709 */
-static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    uint32_t *pu32Reg = NULL;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F09_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
-    Assert(pu32Reg);
-    if(pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    *pResp = 0;
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    *pResp = 0;
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -1137 +1578 @@
         return VINF_SUCCESS;
     }
-    *pResp = pState->paNodes[CODEC_NID(cmd)].node.au32F02_param[cmd & CODEC_VERB_8BIT_DATA];
+    *pResp = pThis->paNodes[CODEC_NID(cmd)].node.au32F02_param[cmd & CODEC_VERB_8BIT_DATA];
     return VINF_SUCCESS;
 }
 
 /* F03 */
-static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F03_param;
+static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F03_param;
     return VINF_SUCCESS;
 }
 
 /* 703 */
-static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-    {
-        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
-    }
+static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
     return VINF_SUCCESS;
 }
 
 /* F0D */
-static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
-    return VINF_SUCCESS;
-}
-
-static int codecSetDigitalConverter(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
+static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
+    return VINF_SUCCESS;
+}
+
+static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU8(&pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
     return VINF_SUCCESS;
 }
 
 /* 70D */
-static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    return codecSetDigitalConverter(pState, cmd, 0, pResp);
+static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    return codecSetDigitalConverter(pThis, cmd, 0, pResp);
 }
 
 /* 70E */
-static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    return codecSetDigitalConverter(pState, cmd, 8, pResp);
+static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    return codecSetDigitalConverter(pThis, cmd, 8, pResp);
 }
 
 /* F20 */
-static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
+static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
     if (CODEC_NID(cmd) == 1 /* AFG */)
-    {
-        *pResp = pState->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
-    }
-    return VINF_SUCCESS;
-}
-
-static int codecSetSubIdX(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    uint32_t *pu32Reg = NULL;
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
+    else
+        *pResp = 0;
+    return VINF_SUCCESS;
+}
+
+static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    uint32_t *pu32Reg;
     if (CODEC_NID(cmd) == 0x1 /* AFG */)
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
-    Assert((pu32Reg));
-    if (pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F20_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
     return VINF_SUCCESS;
 }
 
 /* 720 */
-static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetSubIdX(pState, cmd, 0);
+static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetSubIdX(pThis, cmd, 0);
 }
 
 /* 721 */
-static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetSubIdX(pState, cmd, 8);
+static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetSubIdX(pThis, cmd, 8);
 }
 
 /* 722 */
-static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetSubIdX(pState, cmd, 16);
+static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetSubIdX(pThis, cmd, 16);
 }
 
 /* 723 */
-static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetSubIdX(pState, cmd, 24);
-}
-
-static DECLCALLBACK(int) vrbProcReset(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
+static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetSubIdX(pThis, cmd, 24);
+}
+
+static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
     Assert(CODEC_NID(cmd) == 1 /* AFG */);
-    if(   CODEC_NID(cmd) == 1 /* AFG */
-       && pState->pfnCodecNodeReset)
+    if (   CODEC_NID(cmd) == 1 /* AFG */
+        && pThis->pfnCodecNodeReset)
     {
         uint8_t i;
         Log(("HdaCodec: enters reset\n"));
-        Assert(pState->pfnCodecNodeReset);
-        for (i = 0; i < pState->cTotalNodes; ++i)
+        Assert(pThis->pfnCodecNodeReset);
+        for (i = 0; i < pThis->cTotalNodes; ++i)
         {
-            pState->pfnCodecNodeReset(pState, i, &pState->paNodes[i]);
+            pThis->pfnCodecNodeReset(pThis, i, &pThis->paNodes[i]);
         }
-        pState->fInReset = false;
+        pThis->fInReset = false;
         Log(("HdaCodec: exits reset\n"));
     }
@@ -1308 +1746 @@
 
 /* F05 */
-static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -1319 +1757 @@
     *pResp = 0;
     if (CODEC_NID(cmd) == 1 /* AFG */)
-        *pResp = pState->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
-    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
+    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
     return VINF_SUCCESS;
 }
@@ -1348 +1786 @@
 }
 
-static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    uint32_t *pu32Reg = NULL;
-    *pResp = 0;
+static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32Reg;
     if (CODEC_NID(cmd) == 1 /* AFG */)
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
-    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
-    Assert((pu32Reg));
-    if (!pu32Reg)
-        return VINF_SUCCESS;
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
+    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
 
     bool fReset = CODEC_F05_IS_RESET(*pu32Reg);
@@ -1386 +1823 @@
          */
         *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0,
-                                  CODEC_F05_ACT(pState->paNodes[1].afg.u32F05_param),
+                                  CODEC_F05_ACT(pThis->paNodes[1].afg.u32F05_param),
                                   CODEC_F05_SET(cmd));
     }
@@ -1392 +1829 @@
     /* Propagate next power state only if AFG is on or verb modifies AFG power state */
     if (   CODEC_NID(cmd) == 1 /* AFG */
-        || !CODEC_F05_ACT(pState->paNodes[1].afg.u32F05_param))
+        || !CODEC_F05_ACT(pThis->paNodes[1].afg.u32F05_param))
     {
         *pu32Reg = CODEC_MAKE_F05(fReset, fStopOk, 0, CODEC_F05_SET(cmd), CODEC_F05_SET(cmd));
@@ -1399 +1836 @@
         {
             /* now we're powered on AFG and may propogate power states on nodes */
-            const uint8_t *pu8NodeIndex = &pState->au8Dacs[0];
+            const uint8_t *pu8NodeIndex = &pThis->au8Dacs[0];
             while (*(++pu8NodeIndex))
-                codecPropogatePowerState(&pState->paNodes[*pu8NodeIndex].dac.u32F05_param);
-
-            pu8NodeIndex = &pState->au8Adcs[0];
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].dac.u32F05_param);
+
+            pu8NodeIndex = &pThis->au8Adcs[0];
             while (*(++pu8NodeIndex))
-                codecPropogatePowerState(&pState->paNodes[*pu8NodeIndex].adc.u32F05_param);
-
-            pu8NodeIndex = &pState->au8DigInPins[0];
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].adc.u32F05_param);
+
+            pu8NodeIndex = &pThis->au8DigInPins[0];
             while (*(++pu8NodeIndex))
-                codecPropogatePowerState(&pState->paNodes[*pu8NodeIndex].digin.u32F05_param);
+                codecPropogatePowerState(&pThis->paNodes[*pu8NodeIndex].digin.u32F05_param);
         }
     }
@@ -1415 +1852 @@
 }
 
-static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
+static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
     else if (CODEC_NID(cmd) == 0x1A)
-        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vrbProcSetStreamId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    uint32_t *pu32addr = NULL;
-    *pResp = 0;
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        pu32addr = &pState->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        pu32addr = &pState->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        pu32addr = &pState->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        pu32addr = &pState->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        pu32addr = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
-    Assert((pu32addr));
-    if (pu32addr)
-        hdaCodecSetRegisterU8(pu32addr, cmd, 0);
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32A_param;
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32A_param;
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32A_param;
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32A_param;
-    return VINF_SUCCESS;
-}
-
-static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
-    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
-    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
-    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
-        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vrbProcSetStreamId(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    uint32_t *pu32addr;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        pu32addr = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        pu32addr = &pThis->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        pu32addr = &pThis->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        pu32addr = &pThis->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        pu32addr = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32addr, cmd, 0);
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32A_param;
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adc.u32A_param;
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifout.u32A_param;
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].spdifin.u32A_param;
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
+    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
+    else if (hdaCodecIsSpdifOutNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
+    else if (hdaCodecIsSpdifInNode(pThis, CODEC_NID(cmd)))
+        hdaCodecSetRegisterU16(&pThis->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
     return VINF_SUCCESS;
 }
 
 /* F0C */
-static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
-    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
+static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
+    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
     return VINF_SUCCESS;
 }
 
 /* 70C */
-static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
+static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+
+    *pResp = 0;
+    uint32_t *pu32Reg;
+    if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
+    else if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
+    else
+        AssertFailedReturn(VINF_SUCCESS);
+    hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
+
+    return VINF_SUCCESS;
+}
+
+/* F0F */
+static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
+    return VINF_SUCCESS;
+}
+
+/* 70F */
+static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
     uint32_t *pu32Reg = NULL;
-    if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
-    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
-    *pResp = 0;
-    Assert((pu32Reg));
+    *pResp = 0;
+    if (hdaCodecIsVolKnobNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
+    Assert(pu32Reg);
     if (pu32Reg)
         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
@@ -1553 +2026 @@
 }
 
-/* F0F */
-static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
-    return VINF_SUCCESS;
-}
-
-/* 70F */
-static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+/* F17 */
+static DECLCALLBACK(int) vrbProcGetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    /* note: this is true for ALC885 */
+    if (CODEC_NID(cmd) == 0x1 /* AFG */)
+        *pResp = pThis->paNodes[1].afg.u32F17_param;
+    return VINF_SUCCESS;
+}
+
+/* 717 */
+static DECLCALLBACK(int) vrbProcSetGPIOUnsolisted(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -1581 +2055 @@
     uint32_t *pu32Reg = NULL;
     *pResp = 0;
-    if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
-    Assert((pu32Reg));
+    if (CODEC_NID(cmd) == 1 /* AFG */)
+        pu32Reg = &pThis->paNodes[1].afg.u32F17_param;
+    Assert(pu32Reg);
     if (pu32Reg)
         hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
@@ -1589 +2063 @@
 }
 
-/* F17 */
-static DECLCALLBACK(int) vrbProcGetGPIOUnsolisted(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    /* note: this is true for ALC885 */
-    if (CODEC_NID(cmd) == 0x1 /* AFG */)
-        *pResp = pState->paNodes[1].afg.u32F17_param;
-    return VINF_SUCCESS;
-}
-
-/* 717 */
-static DECLCALLBACK(int) vrbProcSetGPIOUnsolisted(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
+/* F1C */
+static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
+    {
+        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
+        return VINF_SUCCESS;
+    }
+    *pResp = 0;
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
+    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        *pResp = pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
+    return VINF_SUCCESS;
+}
+
+static int codecSetConfigX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    Assert(CODEC_NID(cmd) < pThis->cTotalNodes);
+    if (CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
@@ -1617 +2099 @@
     }
     uint32_t *pu32Reg = NULL;
-    *pResp = 0;
-    if (CODEC_NID(cmd) == 1 /* AFG */)
-        pu32Reg = &pState->paNodes[1].afg.u32F17_param;
-    Assert((pu32Reg));
-    if (pu32Reg)
-        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
-    return VINF_SUCCESS;
-}
-
-/* F1C */
-static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    *pResp = 0;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
-    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
-    return VINF_SUCCESS;
-}
-
-static int codecSetConfigX(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset)
-{
-    Assert((CODEC_CAD(cmd) == pState->id));
-    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
-    if (CODEC_NID(cmd) >= pState->cTotalNodes)
-    {
-        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
-        return VINF_SUCCESS;
-    }
-    uint32_t *pu32Reg = NULL;
-    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
-    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
-    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
-    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
-    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
-    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
-        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
-    Assert((pu32Reg));
+    if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
+    else if (hdaCodecIsDigInPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
+    else if (hdaCodecIsDigOutPinNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
+    else if (hdaCodecIsCdNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
+    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
+    else if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
+        pu32Reg = &pThis->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
+    Assert(pu32Reg);
     if (pu32Reg)
         hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
@@ -1681 +2118 @@
 
 /* 71C */
-static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetConfigX(pState, cmd, 0);
+static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetConfigX(pThis, cmd, 0);
 }
 
 /* 71D */
-static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetConfigX(pState, cmd, 8);
+static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetConfigX(pThis, cmd, 8);
 }
 
 /* 71E */
-static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetConfigX(pState, cmd, 16);
+static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetConfigX(pThis, cmd, 16);
 }
 
 /* 71E */
-static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
-{
-    *pResp = 0;
-    return codecSetConfigX(pState, cmd, 24);
-}
-
-
-static int hdaCodecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt)
-{
-    uint32_t dir = AMPLIFIER_OUT;
-    switch (mt)
-    {
-        case AUD_MIXER_VOLUME:
-        case AUD_MIXER_PCM:
-            dir = AMPLIFIER_OUT;
-            break;
-        case AUD_MIXER_LINE_IN:
-            dir = AMPLIFIER_IN;
-            break;
-    }
-    int mute = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & RT_BIT(7);
-    mute |= AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & RT_BIT(7);
-    mute >>=7;
-    mute &= 0x1;
-    uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_LEFT, 0) & 0x7f;
-    uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, dir, AMPLIFIER_RIGHT, 0) & 0x7f;
-    AUD_set_volume(mt, &mute, &lVol, &rVol);
-    return VINF_SUCCESS;
-}
+static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp)
+{
+    *pResp = 0;
+    return codecSetConfigX(pThis, cmd, 24);
+}
+
 
 /**
@@ -1782 +2196 @@
 };
 
-static int codecLookup(PHDACODEC pState, uint32_t cmd, PPFNCODECVERBPROCESSOR pfn)
-{
-    int rc = VINF_SUCCESS;
-    Assert(CODEC_CAD(cmd) == pState->id);
-    if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
+static int codecLookup(PHDACODEC pThis, uint32_t cmd, PPFNHDACODECVERBPROCESSOR pfn)
+{
+    Assert(CODEC_CAD(cmd) == pThis->id);
+    if (hdaCodecIsReservedNode(pThis, CODEC_NID(cmd)))
         Log(("HdaCodec: cmd %x was addressed to reserved node\n", cmd));
 
     if (   CODEC_VERBDATA(cmd) == 0
-        || CODEC_NID(cmd) >= pState->cTotalNodes)
+        || CODEC_NID(cmd) >= pThis->cTotalNodes)
     {
         *pfn = vrbProcUnimplemented;
@@ -1798 +2211 @@
     }
 
-    for (int i = 0; i < pState->cVerbs; ++i)
-    {
-        if ((CODEC_VERBDATA(cmd) & pState->paVerbs[i].mask) == pState->paVerbs[i].verb)
+    for (int i = 0; i < pThis->cVerbs; ++i)
+    {
+        if ((CODEC_VERBDATA(cmd) & pThis->paVerbs[i].mask) == pThis->paVerbs[i].verb)
         {
-            *pfn = pState->paVerbs[i].pfn;
+            *pfn = pThis->paVerbs[i].pfn;
             return VINF_SUCCESS;
         }
@@ -1809 +2222 @@
     *pfn = vrbProcUnimplemented;
     Log(("HdaCodec: callback for %x wasn't found\n", CODEC_VERBDATA(cmd)));
-    return rc;
+    return VINF_SUCCESS;
 }
 
 static void pi_callback(void *opaque, int avail)
 {
-    PHDACODEC pState = (PHDACODEC)opaque;
-    pState->pfnTransfer(pState, PI_INDEX, avail);
+    PHDACODEC pThis = (PHDACODEC)opaque;
+    pThis->pfnTransfer(pThis, PI_INDEX, avail);
 }
 
 static void po_callback(void *opaque, int avail)
 {
-    PHDACODEC pState = (PHDACODEC)opaque;
-    pState->pfnTransfer(pState, PO_INDEX, avail);
+    PHDACODEC pThis = (PHDACODEC)opaque;
+    pThis->pfnTransfer(pThis, PO_INDEX, avail);
 }
 
@@ -1839 +2252 @@
  *       format) before enabling.
  */
-int hdaCodecOpenVoice(PHDACODEC pState, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings)
-{
-    int rc = 0;
-    Assert((pState && pAudioSettings));
-    if (   !pState
+int hdaCodecOpenVoice(PHDACODEC pThis, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings)
+{
+    int rc;
+    Assert(pThis && pAudioSettings);
+    if (   !pThis
         || !pAudioSettings)
         return -1;
@@ -1849 +2262 @@
     {
         case PI_INDEX:
-            pState->SwVoiceIn = AUD_open_in(&pState->card, pState->SwVoiceIn, "hda.in", pState, pi_callback, pAudioSettings);
-            rc = pState->SwVoiceIn ? 0 : 1;
+            pThis->SwVoiceIn = AUD_open_in(&pThis->card, pThis->SwVoiceIn, "hda.in", pThis, pi_callback, pAudioSettings);
+            rc = pThis->SwVoiceIn ? 0 : 1;
             break;
         case PO_INDEX:
-            pState->SwVoiceOut = AUD_open_out(&pState->card, pState->SwVoiceOut, "hda.out", pState, po_callback, pAudioSettings);
-            rc = pState->SwVoiceOut ? 0 : 1;
+            pThis->SwVoiceOut = AUD_open_out(&pThis->card, pThis->SwVoiceOut, "hda.out", pThis, po_callback, pAudioSettings);
+            rc = pThis->SwVoiceOut ? 0 : 1;
             break;
         default:
@@ -1865 +2278 @@
 
 
-int hdaCodecSaveState(CODECState *pCodecState, PSSMHANDLE pSSM)
-{
-    AssertLogRelMsgReturn(pCodecState->cTotalNodes == 0x1c, ("cTotalNodes=%#x, should be 0x1c", pCodecState->cTotalNodes),
+int hdaCodecSaveState(PHDACODEC pThis, PSSMHANDLE pSSM)
+{
+    AssertLogRelMsgReturn(pThis->cTotalNodes == 0x1c, ("cTotalNodes=%#x, should be 0x1c", pThis->cTotalNodes),
                           VERR_INTERNAL_ERROR);
-    SSMR3PutU32(pSSM, pCodecState->cTotalNodes);
-    for (unsigned idxNode = 0; idxNode < pCodecState->cTotalNodes; ++idxNode)
-        SSMR3PutStructEx(pSSM, &pCodecState->paNodes[idxNode].SavedState, sizeof(pCodecState->paNodes[idxNode].SavedState),
+    SSMR3PutU32(pSSM, pThis->cTotalNodes);
+    for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
+        SSMR3PutStructEx(pSSM, &pThis->paNodes[idxNode].SavedState, sizeof(pThis->paNodes[idxNode].SavedState),
                          0 /*fFlags*/, g_aCodecNodeFields, NULL /*pvUser*/);
     return VINF_SUCCESS;
@@ -1877 +2290 @@
 
 
-int hdaCodecLoadState(CODECState *pCodecState, PSSMHANDLE pSSM, uint32_t uVersion)
+int hdaCodecLoadState(PHDACODEC pThis, PSSMHANDLE pSSM, uint32_t uVersion)
 {
     PCSSMFIELD pFields;
@@ -1884 +2297 @@
     {
         case HDA_SSM_VERSION_1:
-            AssertReturn(pCodecState->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
+            AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
             pFields = g_aCodecNodeFieldsV1;
             fFlags  = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
@@ -1891 +2304 @@
         case HDA_SSM_VERSION_2:
         case HDA_SSM_VERSION_3:
-            AssertReturn(pCodecState->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
+            AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
             pFields = g_aCodecNodeFields;
             fFlags  = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
@@ -1903 +2316 @@
             if (cNodes != 0x1c)
                 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
-            AssertReturn(pCodecState->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
+            AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
 
             pFields = g_aCodecNodeFields;
@@ -1914 +2327 @@
     }
 
-    for (unsigned idxNode = 0; idxNode < pCodecState->cTotalNodes; ++idxNode)
-    {
-        uint8_t idOld = pCodecState->paNodes[idxNode].SavedState.Core.id;
-        int rc = SSMR3GetStructEx(pSSM, &pCodecState->paNodes[idxNode].SavedState,
-                                  sizeof(pCodecState->paNodes[idxNode].SavedState),
+    for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
+    {
+        uint8_t idOld = pThis->paNodes[idxNode].SavedState.Core.id;
+        int rc = SSMR3GetStructEx(pSSM, &pThis->paNodes[idxNode].SavedState,
+                                  sizeof(pThis->paNodes[idxNode].SavedState),
                                   fFlags, pFields, NULL);
         if (RT_FAILURE(rc))
             return rc;
-        AssertLogRelMsgReturn(idOld == pCodecState->paNodes[idxNode].SavedState.Core.id,
-                              ("loaded %#x, expected \n", pCodecState->paNodes[idxNode].SavedState.Core.id, idOld),
+        AssertLogRelMsgReturn(idOld == pThis->paNodes[idxNode].SavedState.Core.id,
+                              ("loaded %#x, expected \n", pThis->paNodes[idxNode].SavedState.Core.id, idOld),
                               VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
     }
@@ -1930 +2343 @@
      * Update stuff after changing the state.
      */
-    if (hdaCodecIsDacNode(pCodecState, pCodecState->u8DacLineOut))
-        hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
-    else if (hdaCodecIsSpdifOutNode(pCodecState, pCodecState->u8DacLineOut))
-        hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].spdifout.B_params, AUD_MIXER_VOLUME);
-    hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
-
-    return VINF_SUCCESS;
-}
-
-
-int hdaCodecDestruct(CODECState *pCodecState)
-{
-    RTMemFree(pCodecState->paNodes);
-    pCodecState->paNodes = NULL;
-    return VINF_SUCCESS;
-}
-
-
-int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pState, PCFGMNODE pCfg)
-{
-    pState->paVerbs   = &g_aCodecVerbs[0];
-    pState->cVerbs    = RT_ELEMENTS(g_aCodecVerbs);
-    pState->pfnLookup = codecLookup;
-    int rc = stac9220Construct(pState);
+    if (hdaCodecIsDacNode(pThis, pThis->u8DacLineOut))
+        hdaCodecToAudVolume(&pThis->paNodes[pThis->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
+    else if (hdaCodecIsSpdifOutNode(pThis, pThis->u8DacLineOut))
+        hdaCodecToAudVolume(&pThis->paNodes[pThis->u8DacLineOut].spdifout.B_params, AUD_MIXER_VOLUME);
+    hdaCodecToAudVolume(&pThis->paNodes[pThis->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
+
+    return VINF_SUCCESS;
+}
+
+
+int hdaCodecDestruct(PHDACODEC pThis)
+{
+    RTMemFree(pThis->paNodes);
+    pThis->paNodes = NULL;
+    return VINF_SUCCESS;
+}
+
+
+int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, PCFGMNODE pCfg)
+{
+    pThis->paVerbs   = &g_aCodecVerbs[0];
+    pThis->cVerbs    = RT_ELEMENTS(g_aCodecVerbs);
+    pThis->pfnLookup = codecLookup;
+    int rc = stac9220Construct(pThis);
     AssertRC(rc);
 
     /* common root node initializers */
-    pState->paNodes[0].node.au32F00_param[0] = CODEC_MAKE_F00_00(pState->u16VendorId, pState->u16DeviceId);
-    pState->paNodes[0].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
+    pThis->paNodes[0].node.au32F00_param[0] = CODEC_MAKE_F00_00(pThis->u16VendorId, pThis->u16DeviceId);
+    pThis->paNodes[0].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
     /* common AFG node initializers */
-    pState->paNodes[1].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x2, pState->cTotalNodes - 2);
-    pState->paNodes[1].node.au32F00_param[5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
-    pState->paNodes[1].afg.u32F20_param = CODEC_MAKE_F20(pState->u16VendorId, pState->u8BSKU, pState->u8AssemblyId);
-
-    //** @todo r=michaln: Was this meant to be 'HDA' or something like that? (AC'97 was on ICH0)
-    AUD_register_card ("ICH0", &pState->card);
+    pThis->paNodes[1].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x2, pThis->cTotalNodes - 2);
+    pThis->paNodes[1].node.au32F00_param[5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
+    pThis->paNodes[1].afg.u32F20_param = CODEC_MAKE_F20(pThis->u16VendorId, pThis->u8BSKU, pThis->u8AssemblyId);
+
+    /// @todo r=michaln: Was this meant to be 'HDA' or something like that? (AC'97 was on ICH0)
+    AUD_register_card ("ICH0", &pThis->card);
 
     /* 44.1 kHz */
@@ -1974 +2387 @@
     as.endianness = 0;
 
-    pState->paNodes[1].node.au32F00_param[0xA] = CODEC_F00_0A_16_BIT;
-    hdaCodecOpenVoice(pState, PI_INDEX, &as);
-    hdaCodecOpenVoice(pState, PO_INDEX, &as);
-    pState->paNodes[1].node.au32F00_param[0xA] |= CODEC_F00_0A_44_1KHZ;
+    pThis->paNodes[1].node.au32F00_param[0xA] = CODEC_F00_0A_16_BIT;
+    hdaCodecOpenVoice(pThis, PI_INDEX, &as);
+    hdaCodecOpenVoice(pThis, PO_INDEX, &as);
+    pThis->paNodes[1].node.au32F00_param[0xA] |= CODEC_F00_0A_44_1KHZ;
 
     uint8_t i;
-    Assert(pState->paNodes);
-    Assert(pState->pfnCodecNodeReset);
-    for (i = 0; i < pState->cTotalNodes; ++i)
-    {
-        pState->pfnCodecNodeReset(pState, i, &pState->paNodes[i]);
-    }
-
-    hdaCodecToAudVolume(&pState->paNodes[pState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
-    hdaCodecToAudVolume(&pState->paNodes[pState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
+    Assert(pThis->paNodes);
+    Assert(pThis->pfnCodecNodeReset);
+    for (i = 0; i < pThis->cTotalNodes; ++i)
+    {
+        pThis->pfnCodecNodeReset(pThis, i, &pThis->paNodes[i]);
+    }
+
+    hdaCodecToAudVolume(&pThis->paNodes[pThis->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
+    hdaCodecToAudVolume(&pThis->paNodes[pThis->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
 
     /* If no host voices were created, then fallback to nul audio. */
-    if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
+    if (!AUD_is_host_voice_in_ok(pThis->SwVoiceIn))
         LogRel (("HDA: WARNING: Unable to open PCM IN!\n"));
-    if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
+    if (!AUD_is_host_voice_out_ok(pThis->SwVoiceOut))
         LogRel (("HDA: WARNING: Unable to open PCM OUT!\n"));
 
-    if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
-        && !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
+    if (   !AUD_is_host_voice_in_ok(pThis->SwVoiceIn)
+        && !AUD_is_host_voice_out_ok(pThis->SwVoiceOut))
     {
         /* Was not able initialize *any* voice. Select the NULL audio driver instead */
-        AUD_close_in  (&pState->card, pState->SwVoiceIn);
-        AUD_close_out (&pState->card, pState->SwVoiceOut);
-        pState->SwVoiceOut = NULL;
-        pState->SwVoiceIn = NULL;
+        AUD_close_in  (&pThis->card, pThis->SwVoiceIn);
+        AUD_close_out (&pThis->card, pThis->SwVoiceOut);
+        pThis->SwVoiceOut = NULL;
+        pThis->SwVoiceIn = NULL;
         AUD_init_null ();
 
@@ -2010 +2423 @@
                 "with the consequence that no sound is audible"));
     }
-    else if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
-             || !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
+    else if (   !AUD_is_host_voice_in_ok(pThis->SwVoiceIn)
+             || !AUD_is_host_voice_out_ok(pThis->SwVoiceOut))
     {
         char   szMissingVoices[128];
         size_t len = 0;
-        if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
+        if (!AUD_is_host_voice_in_ok(pThis->SwVoiceIn))
             len = RTStrPrintf (szMissingVoices, sizeof(szMissingVoices), "PCM_in");
-        if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
+        if (!AUD_is_host_voice_out_ok(pThis->SwVoiceOut))
             len += RTStrPrintf (szMissingVoices + len, sizeof(szMissingVoices) - len, len ? ", PCM_out" : "PCM_out");
 

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

@@ -19 +19 @@
 #define DEV_CODEC_H
 
-struct CODECState;
+/** The ICH HDA (Intel) codec state. */
+typedef struct HDACODEC HDACODEC;
+/** Pointer to the Intel ICH HDA codec state. */
+typedef HDACODEC *PHDACODEC;
 
-typedef DECLCALLBACK(int) FNCODECVERBPROCESSOR(struct CODECState *pThis, uint32_t cmd, uint64_t *pResp);
-typedef FNCODECVERBPROCESSOR *PFNCODECVERBPROCESSOR;
-typedef FNCODECVERBPROCESSOR **PPFNCODECVERBPROCESSOR;
+/**
+ * Verb processor method.
+ */
+typedef DECLCALLBACK(int) FNHDACODECVERBPROCESSOR(PHDACODEC pThis, uint32_t cmd, uint64_t *pResp);
+typedef FNHDACODECVERBPROCESSOR *PFNHDACODECVERBPROCESSOR;
+typedef FNHDACODECVERBPROCESSOR **PPFNHDACODECVERBPROCESSOR;
 
 /* PRM 5.3.1 */
 #define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
-
-#define CODEC_CAD_MASK              0xF0000000
-#define CODEC_CAD_SHIFT             28
-#define CODEC_DIRECT_MASK           RT_BIT(27)
-#define CODEC_NID_MASK              0x07F00000
-#define CODEC_NID_SHIFT             20
-#define CODEC_VERBDATA_MASK         0x000FFFFF
-#define CODEC_VERB_4BIT_CMD         0x000FFFF0
-#define CODEC_VERB_4BIT_DATA        0x0000000F
-#define CODEC_VERB_8BIT_CMD         0x000FFF00
-#define CODEC_VERB_8BIT_DATA        0x000000FF
-#define CODEC_VERB_16BIT_CMD        0x000F0000
-#define CODEC_VERB_16BIT_DATA       0x0000FFFF
-
-#define CODEC_CAD(cmd) ((cmd) & CODEC_CAD_MASK)
-#define CODEC_DIRECT(cmd) ((cmd) & CODEC_DIRECT_MASK)
-#define CODEC_NID(cmd) ((((cmd) & CODEC_NID_MASK)) >> CODEC_NID_SHIFT)
-#define CODEC_VERBDATA(cmd) ((cmd) & CODEC_VERBDATA_MASK)
-#define CODEC_VERB_CMD(cmd, mask, x) (((cmd) & (mask)) >> (x))
-#define CODEC_VERB_CMD4(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_4BIT_CMD, 4))
-#define CODEC_VERB_CMD8(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_8BIT_CMD, 8))
-#define CODEC_VERB_CMD16(cmd) (CODEC_VERB_CMD((cmd), CODEC_VERB_16BIT_CMD, 16))
-#define CODEC_VERB_PAYLOAD4(cmd) ((cmd) & CODEC_VERB_4BIT_DATA)
-#define CODEC_VERB_PAYLOAD8(cmd) ((cmd) & CODEC_VERB_8BIT_DATA)
-#define CODEC_VERB_PAYLOAD16(cmd) ((cmd) & CODEC_VERB_16BIT_DATA)
-
-#define CODEC_VERB_GET_AMP_DIRECTION  RT_BIT(15)
-#define CODEC_VERB_GET_AMP_SIDE       RT_BIT(13)
-#define CODEC_VERB_GET_AMP_INDEX      0x7
-
-/* HDA spec 7.3.3.7 NoteA */
-#define CODEC_GET_AMP_DIRECTION(cmd)  (((cmd) & CODEC_VERB_GET_AMP_DIRECTION) >> 15)
-#define CODEC_GET_AMP_SIDE(cmd)       (((cmd) & CODEC_VERB_GET_AMP_SIDE) >> 13)
-#define CODEC_GET_AMP_INDEX(cmd)      (CODEC_GET_AMP_DIRECTION(cmd) ? 0 : ((cmd) & CODEC_VERB_GET_AMP_INDEX))
-
-/* HDA spec 7.3.3.7 NoteC */
-#define CODEC_VERB_SET_AMP_OUT_DIRECTION  RT_BIT(15)
-#define CODEC_VERB_SET_AMP_IN_DIRECTION   RT_BIT(14)
-#define CODEC_VERB_SET_AMP_LEFT_SIDE      RT_BIT(13)
-#define CODEC_VERB_SET_AMP_RIGHT_SIDE     RT_BIT(12)
-#define CODEC_VERB_SET_AMP_INDEX          (0x7 << 8)
-
-#define CODEC_SET_AMP_IS_OUT_DIRECTION(cmd)  (((cmd) & CODEC_VERB_SET_AMP_OUT_DIRECTION) != 0)
-#define CODEC_SET_AMP_IS_IN_DIRECTION(cmd)   (((cmd) & CODEC_VERB_SET_AMP_IN_DIRECTION) != 0)
-#define CODEC_SET_AMP_IS_LEFT_SIDE(cmd)      (((cmd) & CODEC_VERB_SET_AMP_LEFT_SIDE) != 0)
-#define CODEC_SET_AMP_IS_RIGHT_SIDE(cmd)     (((cmd) & CODEC_VERB_SET_AMP_RIGHT_SIDE) != 0)
-#define CODEC_SET_AMP_INDEX(cmd)             (((cmd) & CODEC_VERB_SET_AMP_INDEX) >> 7)
-
-/* HDA spec 7.3.3.1 defines layout of configuration registers/verbs (0xF00) */
-/* VendorID (7.3.4.1) */
-#define CODEC_MAKE_F00_00(vendorID, deviceID) (((vendorID) << 16) | (deviceID))
-#define CODEC_F00_00_VENDORID(f00_00) (((f00_00) >> 16) & 0xFFFF)
-#define CODEC_F00_00_DEVICEID(f00_00) ((f00_00) & 0xFFFF)
-/* RevisionID (7.3.4.2)*/
-#define CODEC_MAKE_F00_02(MajRev, MinRev, RevisionID, SteppingID) (((MajRev) << 20)|((MinRev) << 16)|((RevisionID) << 8)|(SteppingID))
-/* Subordinate node count (7.3.4.3)*/
-#define CODEC_MAKE_F00_04(startNodeNumber, totalNodeNumber) ((((startNodeNumber) & 0xFF) << 16)|((totalNodeNumber) & 0xFF))
-#define CODEC_F00_04_TO_START_NODE_NUMBER(f00_04) (((f00_04) >> 16) & 0xFF)
-#define CODEC_F00_04_TO_NODE_COUNT(f00_04) ((f00_04) & 0xFF)
-/*
- * Function Group Type  (7.3.4.4)
- * 0 & [0x3-0x7f] are reserved types
- * [0x80 - 0xff] are vendor defined function groups
- */
-#define CODEC_MAKE_F00_05(UnSol, NodeType) (((UnSol) << 8)|(NodeType))
-#define CODEC_F00_05_UNSOL  RT_BIT(8)
-#define CODEC_F00_05_AFG    (0x1)
-#define CODEC_F00_05_MFG    (0x2)
-#define CODEC_F00_05_IS_UNSOL(f00_05) RT_BOOL((f00_05) & RT_BIT(8))
-#define CODEC_F00_05_GROUP(f00_05) ((f00_05) & 0xff)
-/*  Audio Function Group capabilities (7.3.4.5) */
-#define CODEC_MAKE_F00_08(BeepGen, InputDelay, OutputDelay) ((((BeepGen) & 0x1) << 16)| (((InputDelay) & 0xF) << 8) | ((OutputDelay) & 0xF))
-#define CODEC_F00_08_BEEP_GEN(f00_08) ((f00_08) & RT_BIT(16)
-
-/* Widget Capabilities (7.3.4.6) */
-#define CODEC_MAKE_F00_09(type, delay, chanel_count) \
-    ( (((type) & 0xF) << 20)            \
-    | (((delay) & 0xF) << 16)           \
-    | (((chanel_count) & 0xF) << 13))
-/* note: types 0x8-0xe are reserved */
-#define CODEC_F00_09_TYPE_AUDIO_OUTPUT      (0x0)
-#define CODEC_F00_09_TYPE_AUDIO_INPUT       (0x1)
-#define CODEC_F00_09_TYPE_AUDIO_MIXER       (0x2)
-#define CODEC_F00_09_TYPE_AUDIO_SELECTOR    (0x3)
-#define CODEC_F00_09_TYPE_PIN_COMPLEX       (0x4)
-#define CODEC_F00_09_TYPE_POWER_WIDGET      (0x5)
-#define CODEC_F00_09_TYPE_VOLUME_KNOB       (0x6)
-#define CODEC_F00_09_TYPE_BEEP_GEN          (0x7)
-#define CODEC_F00_09_TYPE_VENDOR_DEFINED    (0xF)
-
-#define CODEC_F00_09_CAP_CP                 RT_BIT(12)
-#define CODEC_F00_09_CAP_L_R_SWAP           RT_BIT(11)
-#define CODEC_F00_09_CAP_POWER_CTRL         RT_BIT(10)
-#define CODEC_F00_09_CAP_DIGITAL            RT_BIT(9)
-#define CODEC_F00_09_CAP_CONNECTION_LIST    RT_BIT(8)
-#define CODEC_F00_09_CAP_UNSOL              RT_BIT(7)
-#define CODEC_F00_09_CAP_PROC_WIDGET        RT_BIT(6)
-#define CODEC_F00_09_CAP_STRIPE             RT_BIT(5)
-#define CODEC_F00_09_CAP_FMT_OVERRIDE       RT_BIT(4)
-#define CODEC_F00_09_CAP_AMP_FMT_OVERRIDE   RT_BIT(3)
-#define CODEC_F00_09_CAP_OUT_AMP_PRESENT    RT_BIT(2)
-#define CODEC_F00_09_CAP_IN_AMP_PRESENT     RT_BIT(1)
-#define CODEC_F00_09_CAP_LSB                RT_BIT(0)
-
-#define CODEC_F00_09_TYPE(f00_09) (((f00_09) >> 20) & 0xF)
-
-#define CODEC_F00_09_IS_CAP_CP(f00_09)              RT_BOOL((f00_09) & RT_BIT(12))
-#define CODEC_F00_09_IS_CAP_L_R_SWAP(f00_09)        RT_BOOL((f00_09) & RT_BIT(11))
-#define CODEC_F00_09_IS_CAP_POWER_CTRL(f00_09)      RT_BOOL((f00_09) & RT_BIT(10))
-#define CODEC_F00_09_IS_CAP_DIGITAL(f00_09)         RT_BOOL((f00_09) & RT_BIT(9))
-#define CODEC_F00_09_IS_CAP_CONNECTION_LIST(f00_09) RT_BOOL((f00_09) & RT_BIT(8))
-#define CODEC_F00_09_IS_CAP_UNSOL(f00_09)           RT_BOOL((f00_09) & RT_BIT(7))
-#define CODEC_F00_09_IS_CAP_PROC_WIDGET(f00_09)     RT_BOOL((f00_09) & RT_BIT(6))
-#define CODEC_F00_09_IS_CAP_STRIPE(f00_09)          RT_BOOL((f00_09) & RT_BIT(5))
-#define CODEC_F00_09_IS_CAP_FMT_OVERRIDE(f00_09)    RT_BOOL((f00_09) & RT_BIT(4))
-#define CODEC_F00_09_IS_CAP_AMP_OVERRIDE(f00_09)    RT_BOOL((f00_09) & RT_BIT(3))
-#define CODEC_F00_09_IS_CAP_OUT_AMP_PRESENT(f00_09) RT_BOOL((f00_09) & RT_BIT(2))
-#define CODEC_F00_09_IS_CAP_IN_AMP_PRESENT(f00_09)  RT_BOOL((f00_09) & RT_BIT(1))
-#define CODEC_F00_09_IS_CAP_LSB(f00_09)             RT_BOOL((f00_09) & RT_BIT(0))
-
-/* Supported PCM size, rates (7.3.4.7) */
-#define CODEC_F00_0A_32_BIT             RT_BIT(19)
-#define CODEC_F00_0A_24_BIT             RT_BIT(18)
-#define CODEC_F00_0A_16_BIT             RT_BIT(17)
-#define CODEC_F00_0A_8_BIT              RT_BIT(16)
-
-#define CODEC_F00_0A_48KHZ_MULT_8X      RT_BIT(11)
-#define CODEC_F00_0A_48KHZ_MULT_4X      RT_BIT(10)
-#define CODEC_F00_0A_44_1KHZ_MULT_4X    RT_BIT(9)
-#define CODEC_F00_0A_48KHZ_MULT_2X      RT_BIT(8)
-#define CODEC_F00_0A_44_1KHZ_MULT_2X    RT_BIT(7)
-#define CODEC_F00_0A_48KHZ              RT_BIT(6)
-#define CODEC_F00_0A_44_1KHZ            RT_BIT(5)
-/* 2/3 * 48kHz */
-#define CODEC_F00_0A_48KHZ_2_3X         RT_BIT(4)
-/* 1/2 * 44.1kHz */
-#define CODEC_F00_0A_44_1KHZ_1_2X       RT_BIT(3)
-/* 1/3 * 48kHz */
-#define CODEC_F00_0A_48KHZ_1_3X         RT_BIT(2)
-/* 1/4 * 44.1kHz */
-#define CODEC_F00_0A_44_1KHZ_1_4X       RT_BIT(1)
-/* 1/6 * 48kHz */
-#define CODEC_F00_0A_48KHZ_1_6X         RT_BIT(0)
-
-/* Supported streams formats (7.3.4.8) */
-#define CODEC_F00_0B_AC3                RT_BIT(2)
-#define CODEC_F00_0B_FLOAT32            RT_BIT(1)
-#define CODEC_F00_0B_PCM                RT_BIT(0)
-
-/* Pin Capabilities (7.3.4.9)*/
-#define CODEC_MAKE_F00_0C(vref_ctrl) (((vref_ctrl) & 0xFF) << 8)
-#define CODEC_F00_0C_CAP_HBR                    RT_BIT(27)
-#define CODEC_F00_0C_CAP_DP                     RT_BIT(24)
-#define CODEC_F00_0C_CAP_EAPD                   RT_BIT(16)
-#define CODEC_F00_0C_CAP_HDMI                   RT_BIT(7)
-#define CODEC_F00_0C_CAP_BALANCED_IO            RT_BIT(6)
-#define CODEC_F00_0C_CAP_INPUT                  RT_BIT(5)
-#define CODEC_F00_0C_CAP_OUTPUT                 RT_BIT(4)
-#define CODEC_F00_0C_CAP_HP                     RT_BIT(3)
-#define CODEC_F00_0C_CAP_PRESENSE_DETECT        RT_BIT(2)
-#define CODEC_F00_0C_CAP_TRIGGER_REQUIRED       RT_BIT(1)
-#define CODEC_F00_0C_CAP_IMPENDANCE_SENSE       RT_BIT(0)
-
-#define CODEC_F00_0C_IS_CAP_HBR(f00_0c)                    ((f00_0c) & RT_BIT(27))
-#define CODEC_F00_0C_IS_CAP_DP(f00_0c)                     ((f00_0c) & RT_BIT(24))
-#define CODEC_F00_0C_IS_CAP_EAPD(f00_0c)                   ((f00_0c) & RT_BIT(16))
-#define CODEC_F00_0C_IS_CAP_HDMI(f00_0c)                   ((f00_0c) & RT_BIT(7))
-#define CODEC_F00_0C_IS_CAP_BALANCED_IO(f00_0c)            ((f00_0c) & RT_BIT(6))
-#define CODEC_F00_0C_IS_CAP_INPUT(f00_0c)                  ((f00_0c) & RT_BIT(5))
-#define CODEC_F00_0C_IS_CAP_OUTPUT(f00_0c)                 ((f00_0c) & RT_BIT(4))
-#define CODEC_F00_0C_IS_CAP_HP(f00_0c)                     ((f00_0c) & RT_BIT(3))
-#define CODEC_F00_0C_IS_CAP_PRESENSE_DETECT(f00_0c)        ((f00_0c) & RT_BIT(2))
-#define CODEC_F00_0C_IS_CAP_TRIGGER_REQUIRED(f00_0c)       ((f00_0c) & RT_BIT(1))
-#define CODEC_F00_0C_IS_CAP_IMPENDANCE_SENSE(f00_0c)       ((f00_0c) & RT_BIT(0))
-
-/* Input Amplifier capabilities (7.3.4.10) */
-#define CODEC_MAKE_F00_0D(mute_cap, step_size, num_steps, offset) \
-        (  (((mute_cap) & 0x1) << 31)                             \
-         | (((step_size) & 0xFF) << 16)                           \
-         | (((num_steps) & 0xFF) << 8)                            \
-         | ((offset) & 0xFF))
-
-/* Output Amplifier capabilities (7.3.4.10) */
-#define CODEC_MAKE_F00_12 CODEC_MAKE_F00_0D
-
-/* Connection list lenght (7.3.4.11) */
-#define CODEC_MAKE_F00_0E(long_form, length)    \
-    (  (((long_form) & 0x1) << 7)               \
-     | ((length) & 0x7F))
-#define CODEC_F00_0E_IS_LONG(f00_0e) RT_BOOL((f00_0e) & RT_BIT(7))
-#define CODEC_F00_0E_COUNT(f00_0e) ((f00_0e) & 0x7F)
-/* Supported Power States (7.3.4.12) */
-#define CODEC_F00_0F_EPSS       RT_BIT(31)
-#define CODEC_F00_0F_CLKSTOP    RT_BIT(30)
-#define CODEC_F00_0F_S3D3       RT_BIT(29)
-#define CODEC_F00_0F_D3COLD     RT_BIT(4)
-#define CODEC_F00_0F_D3         RT_BIT(3)
-#define CODEC_F00_0F_D2         RT_BIT(2)
-#define CODEC_F00_0F_D1         RT_BIT(1)
-#define CODEC_F00_0F_D0         RT_BIT(0)
-
-/* Processing capabilities 7.3.4.13 */
-#define CODEC_MAKE_F00_10(num, benign) ((((num) & 0xFF) << 8) | ((benign) & 0x1))
-#define CODEC_F00_10_NUM(f00_10) (((f00_10) & (0xFF << 8)) >> 8)
-#define CODEC_F00_10_BENING(f00_10) ((f00_10) & 0x1)
-
-/* CP/IO Count (7.3.4.14) */
-#define CODEC_MAKE_F00_11(wake, unsol, numgpi, numgpo, numgpio) \
-    (  (((wake) & 0x1) << 31)                                   \
-     | (((unsol) & 0x1) << 30)                                  \
-     | (((numgpi) & 0xFF) << 16)                                \
-     | (((numgpo) & 0xFF) << 8)                                 \
-     | ((numgpio) & 0xFF))
-
-/* Processing States (7.3.3.4) */
-#define CODEC_F03_OFF    (0)
-#define CODEC_F03_ON     RT_BIT(0)
-#define CODEC_F03_BENING RT_BIT(1)
-/* Power States (7.3.3.10) */
-#define CODEC_MAKE_F05(reset, stopok, error, act, set)          \
-    (   (((reset) & 0x1) << 10)                                 \
-      | (((stopok) & 0x1) << 9)                                 \
-      | (((error) & 0x1) << 8)                                  \
-      | (((act) & 0x7) << 4)                                    \
-      | ((set) & 0x7))
-#define CODEC_F05_D3COLD    (4)
-#define CODEC_F05_D3        (3)
-#define CODEC_F05_D2        (2)
-#define CODEC_F05_D1        (1)
-#define CODEC_F05_D0        (0)
-
-#define CODEC_F05_IS_RESET(value)   (((value) & RT_BIT(10)) != 0)
-#define CODEC_F05_IS_STOPOK(value)  (((value) & RT_BIT(9)) != 0)
-#define CODEC_F05_IS_ERROR(value)   (((value) & RT_BIT(8)) != 0)
-#define CODEC_F05_ACT(value)        (((value) & 0x7) >> 4)
-#define CODEC_F05_SET(value)        (((value) & 0x7))
-
-#define CODEC_F05_GE(p0, p1) ((p0) <= (p1))
-#define CODEC_F05_LE(p0, p1) ((p0) >= (p1))
-
-/* Pin Widged Control (7.3.3.13) */
-#define CODEC_F07_VREF_HIZ      (0)
-#define CODEC_F07_VREF_50       (0x1)
-#define CODEC_F07_VREF_GROUND   (0x2)
-#define CODEC_F07_VREF_80       (0x4)
-#define CODEC_F07_VREF_100      (0x5)
-#define CODEC_F07_IN_ENABLE     RT_BIT(5)
-#define CODEC_F07_OUT_ENABLE    RT_BIT(6)
-#define CODEC_F07_OUT_H_ENABLE  RT_BIT(7)
-
-/* Unsolicited enabled (7.3.3.14) */
-#define CODEC_MAKE_F08(enable, tag) ((((enable) & 1) << 7) | ((tag) & 0x3F))
-
-/* Converter formats (7.3.3.8) and (3.7.1) */
-#define CODEC_MAKE_A(fNonPCM, f44_1BaseRate, mult, div, bits, chan) \
-    (  (((fNonPCM) & 0x1) << 15)                                    \
-     | (((f44_1BaseRate) & 0x1) << 14)                              \
-     | (((mult) & 0x7) << 11)                                       \
-     | (((div) & 0x7) << 8)                                         \
-     | (((bits) & 0x7) << 4)                                        \
-     | ((chan) & 0xF))
-
-#define CODEC_A_MULT_1X     (0)
-#define CODEC_A_MULT_2X     (1)
-#define CODEC_A_MULT_3X     (2)
-#define CODEC_A_MULT_4X     (3)
-
-#define CODEC_A_DIV_1X      (0)
-#define CODEC_A_DIV_2X      (1)
-#define CODEC_A_DIV_3X      (2)
-#define CODEC_A_DIV_4X      (3)
-#define CODEC_A_DIV_5X      (4)
-#define CODEC_A_DIV_6X      (5)
-#define CODEC_A_DIV_7X      (6)
-#define CODEC_A_DIV_8X      (7)
-
-#define CODEC_A_8_BIT       (0)
-#define CODEC_A_16_BIT      (1)
-#define CODEC_A_20_BIT      (2)
-#define CODEC_A_24_BIT      (3)
-#define CODEC_A_32_BIT      (4)
-
-/* Pin Sense (7.3.3.15) */
-#define CODEC_MAKE_F09_ANALOG(fPresent, impedance)  \
-(  (((fPresent) & 0x1) << 31)                       \
- | (((impedance) & 0x7FFFFFFF)))
-#define CODEC_F09_ANALOG_NA    0x7FFFFFFF
-#define CODEC_MAKE_F09_DIGITAL(fPresent, fELDValid) \
-(   (((fPresent) & 0x1) << 31)                      \
-  | (((fELDValid) & 0x1) << 30))
-
-#define CODEC_MAKE_F0C(lrswap, eapd, btl) ((((lrswap) & 1) << 2) | (((eapd) & 1) << 1) | ((btl) & 1))
-#define CODEC_FOC_IS_LRSWAP(f0c)    RT_BOOL((f0c) & RT_BIT(2))
-#define CODEC_FOC_IS_EAPD(f0c)      RT_BOOL((f0c) & RT_BIT(1))
-#define CODEC_FOC_IS_BTL(f0c)       RT_BOOL((f0c) & RT_BIT(0))
-/* HDA spec 7.3.3.31 defines layout of configuration registers/verbs (0xF1C) */
-/* Configuration's port connection */
-#define CODEC_F1C_PORT_MASK    (0x3)
-#define CODEC_F1C_PORT_SHIFT   (30)
-
-#define CODEC_F1C_PORT_COMPLEX (0x0)
-#define CODEC_F1C_PORT_NO_PHYS (0x1)
-#define CODEC_F1C_PORT_FIXED   (0x2)
-#define CODEC_F1C_BOTH         (0x3)
-
-/* Configuration's location */
-#define CODEC_F1C_LOCATION_MASK  (0x3F)
-#define CODEC_F1C_LOCATION_SHIFT (24)
-/* [4:5] bits of location region means chassis attachment */
-#define CODEC_F1C_LOCATION_PRIMARY_CHASSIS     (0)
-#define CODEC_F1C_LOCATION_INTERNAL            RT_BIT(4)
-#define CODEC_F1C_LOCATION_SECONDRARY_CHASSIS  RT_BIT(5)
-#define CODEC_F1C_LOCATION_OTHER               (RT_BIT(5))
-
-/* [0:3] bits of location region means geometry location attachment */
-#define CODEC_F1C_LOCATION_NA                  (0)
-#define CODEC_F1C_LOCATION_REAR                (0x1)
-#define CODEC_F1C_LOCATION_FRONT               (0x2)
-#define CODEC_F1C_LOCATION_LEFT                (0x3)
-#define CODEC_F1C_LOCATION_RIGTH               (0x4)
-#define CODEC_F1C_LOCATION_TOP                 (0x5)
-#define CODEC_F1C_LOCATION_BOTTOM              (0x6)
-#define CODEC_F1C_LOCATION_SPECIAL_0           (0x7)
-#define CODEC_F1C_LOCATION_SPECIAL_1           (0x8)
-#define CODEC_F1C_LOCATION_SPECIAL_2           (0x9)
-
-/* Configuration's devices */
-#define CODEC_F1C_DEVICE_MASK                  (0xF)
-#define CODEC_F1C_DEVICE_SHIFT                 (20)
-#define CODEC_F1C_DEVICE_LINE_OUT              (0)
-#define CODEC_F1C_DEVICE_SPEAKER               (0x1)
-#define CODEC_F1C_DEVICE_HP                    (0x2)
-#define CODEC_F1C_DEVICE_CD                    (0x3)
-#define CODEC_F1C_DEVICE_SPDIF_OUT             (0x4)
-#define CODEC_F1C_DEVICE_DIGITAL_OTHER_OUT     (0x5)
-#define CODEC_F1C_DEVICE_MODEM_LINE_SIDE       (0x6)
-#define CODEC_F1C_DEVICE_MODEM_HANDSET_SIDE    (0x7)
-#define CODEC_F1C_DEVICE_LINE_IN               (0x8)
-#define CODEC_F1C_DEVICE_AUX                   (0x9)
-#define CODEC_F1C_DEVICE_MIC                   (0xA)
-#define CODEC_F1C_DEVICE_PHONE                 (0xB)
-#define CODEC_F1C_DEVICE_SPDIF_IN              (0xC)
-#define CODEC_F1C_DEVICE_RESERVED              (0xE)
-#define CODEC_F1C_DEVICE_OTHER                 (0xF)
-
-/* Configuration's Connection type */
-#define CODEC_F1C_CONNECTION_TYPE_MASK         (0xF)
-#define CODEC_F1C_CONNECTION_TYPE_SHIFT        (16)
-
-#define CODEC_F1C_CONNECTION_TYPE_UNKNOWN               (0)
-#define CODEC_F1C_CONNECTION_TYPE_1_8INCHES             (0x1)
-#define CODEC_F1C_CONNECTION_TYPE_1_4INCHES             (0x2)
-#define CODEC_F1C_CONNECTION_TYPE_ATAPI                 (0x3)
-#define CODEC_F1C_CONNECTION_TYPE_RCA                   (0x4)
-#define CODEC_F1C_CONNECTION_TYPE_OPTICAL               (0x5)
-#define CODEC_F1C_CONNECTION_TYPE_OTHER_DIGITAL         (0x6)
-#define CODEC_F1C_CONNECTION_TYPE_ANALOG                (0x7)
-#define CODEC_F1C_CONNECTION_TYPE_DIN                   (0x8)
-#define CODEC_F1C_CONNECTION_TYPE_XLR                   (0x9)
-#define CODEC_F1C_CONNECTION_TYPE_RJ_11                 (0xA)
-#define CODEC_F1C_CONNECTION_TYPE_COMBO                 (0xB)
-#define CODEC_F1C_CONNECTION_TYPE_OTHER                 (0xF)
-
-/* Configuration's color */
-#define CODEC_F1C_COLOR_MASK                  (0xF)
-#define CODEC_F1C_COLOR_SHIFT                 (12)
-#define CODEC_F1C_COLOR_UNKNOWN               (0)
-#define CODEC_F1C_COLOR_BLACK                 (0x1)
-#define CODEC_F1C_COLOR_GREY                  (0x2)
-#define CODEC_F1C_COLOR_BLUE                  (0x3)
-#define CODEC_F1C_COLOR_GREEN                 (0x4)
-#define CODEC_F1C_COLOR_RED                   (0x5)
-#define CODEC_F1C_COLOR_ORANGE                (0x6)
-#define CODEC_F1C_COLOR_YELLOW                (0x7)
-#define CODEC_F1C_COLOR_PURPLE                (0x8)
-#define CODEC_F1C_COLOR_PINK                  (0x9)
-#define CODEC_F1C_COLOR_RESERVED_0            (0xA)
-#define CODEC_F1C_COLOR_RESERVED_1            (0xB)
-#define CODEC_F1C_COLOR_RESERVED_2            (0xC)
-#define CODEC_F1C_COLOR_RESERVED_3            (0xD)
-#define CODEC_F1C_COLOR_WHITE                 (0xE)
-#define CODEC_F1C_COLOR_OTHER                 (0xF)
-
-/* Configuration's misc */
-#define CODEC_F1C_MISC_MASK                  (0xF)
-#define CODEC_F1C_MISC_SHIFT                 (8)
-#define CODEC_F1C_MISC_JACK_DETECT           (0)
-#define CODEC_F1C_MISC_RESERVED_0            (1)
-#define CODEC_F1C_MISC_RESERVED_1            (2)
-#define CODEC_F1C_MISC_RESERVED_2            (3)
-
-/* Configuration's association */
-#define CODEC_F1C_ASSOCIATION_MASK                  (0xF)
-#define CODEC_F1C_ASSOCIATION_SHIFT                 (4)
-/* Connection's sequence */
-#define CODEC_F1C_SEQ_MASK                  (0xF)
-#define CODEC_F1C_SEQ_SHIFT                 (0)
-
-/* Implementation identification (7.3.3.30) */
-#define CODEC_MAKE_F20(bmid, bsku, aid)     \
-    (  (((bmid) & 0xFFFF) << 16)            \
-     | (((bsku) & 0xFF) << 8)               \
-     | (((aid) & 0xFF))                     \
-    )
-
-/* macro definition helping in filling the configuration registers. */
-#define CODEC_MAKE_F1C(port_connectivity, location, device, connection_type, color, misc, association, sequence)    \
-    (  ((port_connectivity) << CODEC_F1C_PORT_SHIFT)          \
-     | ((location) << CODEC_F1C_LOCATION_SHIFT)               \
-     | ((device) << CODEC_F1C_DEVICE_SHIFT)                   \
-     | ((connection_type) << CODEC_F1C_CONNECTION_TYPE_SHIFT) \
-     | ((color) << CODEC_F1C_COLOR_SHIFT)                     \
-     | ((misc) << CODEC_F1C_MISC_SHIFT)                       \
-     | ((association) << CODEC_F1C_ASSOCIATION_SHIFT)         \
-     | ((sequence)))
 
 
@@ -450 +41 @@
     /* operation bitness mask */
     uint32_t mask;
-    PFNCODECVERBPROCESSOR pfn;
+    PFNHDACODECVERBPROCESSOR pfn;
 } CODECVERB;
 #endif
@@ -465 +56 @@
 typedef TYPE CODECNODE *PCODECNODE;
 
-
 typedef enum
 {
@@ -475 +65 @@
 
 
-typedef struct CODECState
+typedef struct HDACODEC
 {
     uint16_t                id;
@@ -514 +104 @@
     const uint8_t           u8DacLineOut;
 #endif
-    DECLR3CALLBACKMEMBER(int, pfnProcess, (struct CODECState *));
-    DECLR3CALLBACKMEMBER(void, pfnTransfer, (struct CODECState *pState, ENMSOUNDSOURCE, int avail));
-    /* These callbacks are set by Codec implementation */
-    DECLR3CALLBACKMEMBER(int, pfnLookup, (struct CODECState *pState, uint32_t verb, PPFNCODECVERBPROCESSOR));
-    DECLR3CALLBACKMEMBER(int, pfnReset, (struct CODECState *pState));
-    DECLR3CALLBACKMEMBER(int, pfnCodecNodeReset, (struct CODECState *pState, uint8_t, PCODECNODE));
-    /* These callbacks are set by codec implementation to answer debugger requests */
-    DECLR3CALLBACKMEMBER(void, pfnCodecDbgListNodes, (struct CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
-    DECLR3CALLBACKMEMBER(void, pfnCodecDbgSelector, (struct CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
-} CODECState, *PCODECState;
-/** The ICH HDA (Intel) codec state. */
-typedef CODECState HDACODEC;
-/** Pointer to the Intel ICH HDA codec state. */
-typedef HDACODEC *PHDACODEC;
+    DECLR3CALLBACKMEMBER(int, pfnProcess, (PHDACODEC pCodec));
+    DECLR3CALLBACKMEMBER(void, pfnTransfer, (PHDACODEC pCodec, ENMSOUNDSOURCE, int avail));
+    /* These callbacks are set by Codec implementation. */
+    DECLR3CALLBACKMEMBER(int, pfnLookup, (PHDACODEC pThis, uint32_t verb, PPFNHDACODECVERBPROCESSOR));
+    DECLR3CALLBACKMEMBER(int, pfnReset, (PHDACODEC pThis));
+    DECLR3CALLBACKMEMBER(int, pfnCodecNodeReset, (PHDACODEC pThis, uint8_t, PCODECNODE));
+    /* These callbacks are set by codec implementation to answer debugger requests. */
+    DECLR3CALLBACKMEMBER(void, pfnCodecDbgListNodes, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
+    DECLR3CALLBACKMEMBER(void, pfnCodecDbgSelector, (PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs));
+} CODECState;
 
 int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, PCFGMNODE pCfg);

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

@@ -482 +482 @@
     /** indicates if HDA in reset. */
     bool                    fInReset;
-    CODECState              Codec;
+    /** The HDA codec state. */
+    HDACODEC                Codec;
     /** 1.2.3.4.5.6.7. - someone please tell me what I'm counting! - .8.9.10... */
     uint8_t                 u8Counter;
@@ -985 +986 @@
     uint8_t rirbWp;
 
-    PFNCODECVERBPROCESSOR pfn = (PFNCODECVERBPROCESSOR)NULL;
+    PFNHDACODECVERBPROCESSOR pfn = (PFNHDACODECVERBPROCESSOR)NULL;
 
     rc = hdaCmdSync(pThis, true);
@@ -999 +1000 @@
         uint32_t cmd;
         uint64_t resp;
-        pfn = (PFNCODECVERBPROCESSOR)NULL;
+        pfn = NULL;
         corbRp++;
         cmd = pThis->pu32CorbBuf[corbRp];
@@ -1524 +1525 @@
 static int hdaRegWriteIRS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
 {
-    int rc = VINF_SUCCESS;
-    uint64_t resp;
-    PFNCODECVERBPROCESSOR pfn = (PFNCODECVERBPROCESSOR)NULL;
+    int                         rc  = VINF_SUCCESS;
+    PFNHDACODECVERBPROCESSOR    pfn = NULL;
+    uint64_t                    resp;
+
     /*
      * if guest set the ICB bit of IRS register, HDA should process the verb in IC register,
@@ -1919 +1921 @@
  * @interface_method_impl{HDACODEC,pfnReset}
  */
-DECLCALLBACK(int) hdaCodecReset(CODECState *pCodecState)
-{
-    PHDASTATE pThis = (PHDASTATE)pCodecState->pvHDAState;
+DECLCALLBACK(int) hdaCodecReset(PHDACODEC pCodec)
+{
+    PHDASTATE pThis = (PHDASTATE)pCodec->pvHDAState;
+    NOREF(pThis);
     return VINF_SUCCESS;
 }
@@ -1956 +1959 @@
  * @interface_method_impl{HDACODEC,pfnTransfer}
  */
-static DECLCALLBACK(void) hdaTransfer(CODECState *pCodecState, ENMSOUNDSOURCE src, int avail)
-{
-    PHDASTATE pThis = (PHDASTATE)pCodecState->pvHDAState;
-    uint8_t                 u8Strm = 0;
-    PHDABDLEDESC            pBdle = NULL;
+static DECLCALLBACK(void) hdaTransfer(PHDACODEC pCodec, ENMSOUNDSOURCE src, int avail)
+{
+    PHDASTATE       pThis  = (PHDASTATE)pCodec->pvHDAState;
+    uint8_t         u8Strm = 0;
+    PHDABDLEDESC    pBdle  = NULL;
 
     switch (src)