VirtualBox

Changeset 44667 in vbox


Ignore:
Timestamp:
Feb 13, 2013 2:30:33 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
83760
Message:

HDA codec cleanups.

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

Legend:

Unmodified
Added
Removed

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

    r44639 r44667  
    22/** @file
    33 * DevCodec - VBox ICH Intel HD Audio Codec.
     4 *
     5 * Implemented against "Intel I/O Controller Hub 6 (ICH6) High Definition
     6 * Audio / AC '97 - Programmer's Reference Manual (PRM)", document number
     7 * 302349-003.
    48 */
    59
    610/*
    7  * Copyright (C) 2006-2012 Oracle Corporation
     11 * Copyright (C) 2006-2013 Oracle Corporation
    812 *
    913 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    3943*   Structures and Typedefs                                                    *
    4044*******************************************************************************/
    41 #define CODECNODE_F0_PARAM_LENGTH 0x14
    42 #define CODECNODE_F02_PARAM_LENGTH 16
    43 
     45/** The F00 parameter length (in dwords). */
     46#define CODECNODE_F00_PARAM_LENGTH  20
     47/** The F02 parameter length (in dwords). */
     48#define CODECNODE_F02_PARAM_LENGTH  16
     49
     50/**
     51 * Common (or core) codec node structure.
     52 */
    4453typedef struct CODECCOMMONNODE
    4554{
    46     uint8_t id; /* 7 - bit format */
     55    /** Node id - 7 bit format */
     56    uint8_t         id;
    4757    /** The node name. */
    48     char const *pszName;
    49     /* RPM 5.3.6 */
    50     uint32_t au32F00_param[CODECNODE_F0_PARAM_LENGTH];
     58    char const     *pszName;
     59    /* PRM 5.3.6 */
     60    uint32_t au32F00_param[CODECNODE_F00_PARAM_LENGTH];
    5161    uint32_t au32F02_param[CODECNODE_F02_PARAM_LENGTH];
    52 } CODECCOMMONNODE, *PCODECCOMMONNODE;
    53 AssertCompile(CODECNODE_F0_PARAM_LENGTH == 20);  /* saved state */
     62} CODECCOMMONNODE;
     63typedef CODECCOMMONNODE *PCODECCOMMONNODE;
     64AssertCompile(CODECNODE_F00_PARAM_LENGTH == 20);  /* saved state */
    5465AssertCompile(CODECNODE_F02_PARAM_LENGTH == 16); /* saved state */
    5566
     67/**
     68 * Compile time assertion on the expected node size.
     69 */
    5670#define AssertNodeSize(a_Node, a_cParams) \
    5771    AssertCompile((a_cParams) <= (60 + 6)); /* the max size - saved state */ \
    58     AssertCompile(sizeof(a_Node) - sizeof(CODECCOMMONNODE) == (((a_cParams) * sizeof(uint32_t) + sizeof(void *) - 1) & ~(sizeof(void *) - 1)))
     72    AssertCompile(   sizeof(a_Node) - sizeof(CODECCOMMONNODE)  \
     73                  == (((a_cParams) * sizeof(uint32_t) + sizeof(void *) - 1) & ~(sizeof(void *) - 1)) )
    5974
    6075typedef struct ROOTCODECNODE
    … …  
    267282*******************************************************************************/
    268283/* STAC9220 - Referenced thru STAC9220WIDGET in the constructor below. */
    269 static uint8_t const g_abStac9220Ports[] = { 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0};
    270 static uint8_t const g_abStac9220Dacs[] = { 0x2, 0x3, 0x4, 0x5, 0};
    271 static uint8_t const g_abStac9220Adcs[] = { 0x6, 0x7, 0};
    272 static uint8_t const g_abStac9220SpdifOuts[] = { 0x8, 0 };
    273 static uint8_t const g_abStac9220SpdifIns[] = { 0x9, 0 };
     284static uint8_t const g_abStac9220Ports[]      = { 0x0A, 0xB, 0xC, 0xD, 0xE, 0xF, 0};
     285static uint8_t const g_abStac9220Dacs[]       = { 0x02, 0x3, 0x4, 0x5, 0};
     286static uint8_t const g_abStac9220Adcs[]       = { 0x06, 0x7, 0};
     287static uint8_t const g_abStac9220SpdifOuts[]  = { 0x08, 0 };
     288static uint8_t const g_abStac9220SpdifIns[]   = { 0x09, 0 };
    274289static uint8_t const g_abStac9220DigOutPins[] = { 0x10, 0 };
    275 static uint8_t const g_abStac9220DigInPins[] = { 0x11, 0 };
    276 static uint8_t const g_abStac9220AdcVols[] = { 0x17, 0x18, 0};
    277 static uint8_t const g_abStac9220AdcMuxs[] = { 0x12, 0x13, 0};
    278 static uint8_t const g_abStac9220Pcbeeps[] = { 0x14, 0 };
    279 static uint8_t const g_abStac9220Cds[] = { 0x15, 0 };
    280 static uint8_t const g_abStac9220VolKnobs[] = { 0x16, 0 };
    281 static uint8_t const g_abStac9220Reserveds[] = { 0x9, 0x19, 0x1a, 0x1b, 0 };
     290static uint8_t const g_abStac9220DigInPins[]  = { 0x11, 0 };
     291static uint8_t const g_abStac9220AdcVols[]    = { 0x17, 0x18, 0};
     292static uint8_t const g_abStac9220AdcMuxs[]    = { 0x12, 0x13, 0};
     293static uint8_t const g_abStac9220Pcbeeps[]    = { 0x14, 0 };
     294static uint8_t const g_abStac9220Cds[]        = { 0x15, 0 };
     295static uint8_t const g_abStac9220VolKnobs[]   = { 0x16, 0 };
     296static uint8_t const g_abStac9220Reserveds[]  = { 0x09, 0x19, 0x1a, 0x1b, 0 };
    282297
    283298
    … …  
    309324*   Internal Functions                                                         *
    310325*******************************************************************************/
    311 static int stac9220ResetNode(struct CODECState *pState, uint8_t nodenum, PCODECNODE pNode);
    312 
    313 
    314 
    315 static int stac9220Construct(CODECState *pState)
     326static int stac9220ResetNode(PHDACODEC pState, uint8_t nodenum, PCODECNODE pNode);
     327
     328
     329
     330static int stac9220Construct(PHDACODEC pState)
    316331{
    317332    unconst(pState->cTotalNodes) = 0x1C;
    … …  
    344359}
    345360
    346 static int stac9220ResetNode(struct CODECState *pState, uint8_t nodenum, PCODECNODE pNode)
     361static int stac9220ResetNode(PHDACODEC pState, uint8_t nodenum, PCODECNODE pNode)
    347362{
    348363    pNode->node.id = nodenum;
    … …  
    352367        /* Root Node*/
    353368        case 0:
    354             pNode->node.au32F00_param[2] = CODEC_MAKE_F00_02(0x1, 0x0, 0x34, 0x1); /* rev id */
     369            pNode->node.au32F00_param[0x02] = CODEC_MAKE_F00_02(0x1, 0x0, 0x34, 0x1); /* rev id */
    355370            break;
    356371        case 1:
    357             pNode->node.au32F00_param[8] = CODEC_MAKE_F00_08(1, 0xd, 0xd);
    358             pNode->node.au32F00_param[0xC] =  CODEC_MAKE_F00_0C(0x17)
    359                                              | CODEC_F00_0C_CAP_BALANCED_IO
    360                                              | CODEC_F00_0C_CAP_INPUT
    361                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    362                                              | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    363                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//(17 << 8)|RT_BIT(6)|RT_BIT(5)|RT_BIT(2)|RT_BIT(1)|RT_BIT(0);
    364             pNode->node.au32F00_param[0xB] = CODEC_F00_0B_PCM;
    365             pNode->node.au32F00_param[0xD] = CODEC_MAKE_F00_0D(1, 0x5, 0xE, 0);//RT_BIT(31)|(0x5 << 16)|(0xE)<<8;
     372            pNode->node.au32F00_param[0x08] = CODEC_MAKE_F00_08(1, 0xd, 0xd);
     373            pNode->node.au32F00_param[0x0C] = CODEC_MAKE_F00_0C(0x17)
     374                                            | CODEC_F00_0C_CAP_BALANCED_IO
     375                                            | CODEC_F00_0C_CAP_INPUT
     376                                            | CODEC_F00_0C_CAP_PRESENSE_DETECT
     377                                            | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     378                                            | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//(17 << 8)|RT_BIT(6)|RT_BIT(5)|RT_BIT(2)|RT_BIT(1)|RT_BIT(0);
     379            pNode->node.au32F00_param[0x0B] = CODEC_F00_0B_PCM;
     380            pNode->node.au32F00_param[0x0D] = CODEC_MAKE_F00_0D(1, 0x5, 0xE, 0);//RT_BIT(31)|(0x5 << 16)|(0xE)<<8;
    366381            pNode->node.au32F00_param[0x12] = RT_BIT(31)|(0x2 << 16)|(0x7f << 8)|0x7f;
    367382            pNode->node.au32F00_param[0x11] = CODEC_MAKE_F00_11(1, 1, 0, 0, 4);//0xc0000004;
    368             pNode->node.au32F00_param[0xF] = CODEC_F00_0F_D3|CODEC_F00_0F_D2|CODEC_F00_0F_D1|CODEC_F00_0F_D0;
     383            pNode->node.au32F00_param[0x0F] = CODEC_F00_0F_D3|CODEC_F00_0F_D2|CODEC_F00_0F_D1|CODEC_F00_0F_D0;
    369384            pNode->afg.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D2, CODEC_F05_D2);//0x2 << 4| 0x2; /* PS-Act: D3, PS->Set D3  */
    370385            pNode->afg.u32F08_param = 0;
    … …  
    381396            AMPLIFIER_REGISTER(pNode->dac.B_params, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) = 0x7F | RT_BIT(7);
    382397
    383             pNode->dac.node.au32F00_param[9] =  CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0xD, 0)
    384                                               | CODEC_F00_09_CAP_L_R_SWAP
    385                                               | CODEC_F00_09_CAP_POWER_CTRL
    386                                               | CODEC_F00_09_CAP_OUT_AMP_PRESENT
    387                                               | CODEC_F00_09_CAP_LSB;//(0xD << 16) | RT_BIT(11) |  RT_BIT(10) | RT_BIT(2) | RT_BIT(0);
     398            pNode->dac.node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0xD, 0)
     399                                             | CODEC_F00_09_CAP_L_R_SWAP
     400                                             | CODEC_F00_09_CAP_POWER_CTRL
     401                                             | CODEC_F00_09_CAP_OUT_AMP_PRESENT
     402                                             | CODEC_F00_09_CAP_LSB;//(0xD << 16) | RT_BIT(11) |  RT_BIT(10) | RT_BIT(2) | RT_BIT(0);
    388403            pNode->dac.u32F0c_param = 0;
    389404            pNode->dac.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3);//0x3 << 4 | 0x3; /* PS-Act: D3, Set: D3  */
    390         break;
     405            break;
    391406        case 6:
    392407            pNode->node.au32F02_param[0] = 0x17;
    … …  
    400415            pNode->adc.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3);//0x3 << 4 | 0x3; /* PS-Act: D3 Set: D3 */
    401416            pNode->adc.u32F06_param = 0;
    402             pNode->adc.node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 0xD, 0)
    403                                                | CODEC_F00_09_CAP_POWER_CTRL
    404                                                | CODEC_F00_09_CAP_CONNECTION_LIST
    405                                                | CODEC_F00_09_CAP_PROC_WIDGET
    406                                                | CODEC_F00_09_CAP_LSB;//RT_BIT(20)| (0xd << 16) |  RT_BIT(10) | RT_BIT(8) | RT_BIT(6)| RT_BIT(0);
     417            pNode->adc.node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 0xD, 0)
     418                                             | CODEC_F00_09_CAP_POWER_CTRL
     419                                             | CODEC_F00_09_CAP_CONNECTION_LIST
     420                                             | CODEC_F00_09_CAP_PROC_WIDGET
     421                                             | CODEC_F00_09_CAP_LSB;//RT_BIT(20)| (0xd << 16) |  RT_BIT(10) | RT_BIT(8) | RT_BIT(6)| RT_BIT(0);
    407422            break;
    408423        case 8:
    409424            pNode->spdifout.u32A_param = CODEC_MAKE_A(0, 1, CODEC_A_MULT_1X, CODEC_A_DIV_1X, CODEC_A_16_BIT, 1);//(1<<14)|(0x1<<4) | 0x1;
    410             pNode->spdifout.node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0x4, 0)
    411                                                     | CODEC_F00_09_CAP_DIGITAL
    412                                                     | CODEC_F00_09_CAP_FMT_OVERRIDE
    413                                                     | CODEC_F00_09_CAP_LSB;//(4 << 16) | RT_BIT(9)|RT_BIT(4)|0x1;
     425            pNode->spdifout.node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0x4, 0)
     426                                                  | CODEC_F00_09_CAP_DIGITAL
     427                                                  | CODEC_F00_09_CAP_FMT_OVERRIDE
     428                                                  | CODEC_F00_09_CAP_LSB;//(4 << 16) | RT_BIT(9)|RT_BIT(4)|0x1;
    414429            pNode->node.au32F00_param[0xa] = pState->paNodes[1].node.au32F00_param[0xA];
    415430            pNode->spdifout.node.au32F00_param[0xB] = CODEC_F00_0B_PCM;
    416431            pNode->spdifout.u32F06_param = 0;
    417432            pNode->spdifout.u32F0d_param = 0;
    418         break;
     433            break;
    419434        case 9:
    420435            pNode->spdifin.u32A_param = CODEC_MAKE_A(0, 1, CODEC_A_MULT_1X, CODEC_A_DIV_1X, CODEC_A_16_BIT, 1);//(0x1<<4) | 0x1;
    421             pNode->spdifin.node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 0x4, 0)
    422                                                    | CODEC_F00_09_CAP_DIGITAL
    423                                                    | CODEC_F00_09_CAP_CONNECTION_LIST
    424                                                    | CODEC_F00_09_CAP_FMT_OVERRIDE
    425                                                    | CODEC_F00_09_CAP_LSB;//(0x1 << 20)|(4 << 16) | RT_BIT(9)| RT_BIT(8)|RT_BIT(4)|0x1;
     436            pNode->spdifin.node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_INPUT, 0x4, 0)
     437                                                 | CODEC_F00_09_CAP_DIGITAL
     438                                                 | CODEC_F00_09_CAP_CONNECTION_LIST
     439                                                 | CODEC_F00_09_CAP_FMT_OVERRIDE
     440                                                 | CODEC_F00_09_CAP_LSB;//(0x1 << 20)|(4 << 16) | RT_BIT(9)| RT_BIT(8)|RT_BIT(4)|0x1;
    426441            pNode->node.au32F00_param[0xA] = pState->paNodes[1].node.au32F00_param[0xA];
    427442            pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 1);//RT_BIT(0);
    … …  
    430445            pNode->spdifin.u32F06_param = 0;
    431446            pNode->spdifin.u32F0d_param = 0;
    432         break;
     447            break;
    433448        case 0xA:
    434             pNode->node.au32F00_param[0xC] =   CODEC_MAKE_F00_0C(0x17)
    435                                              | CODEC_F00_0C_CAP_INPUT
    436                                              | CODEC_F00_0C_CAP_OUTPUT
    437                                              | CODEC_F00_0C_CAP_HP
    438                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    439                                              | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    440                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x173f;
     449            pNode->node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
     450                                           | CODEC_F00_0C_CAP_INPUT
     451                                           | CODEC_F00_0C_CAP_OUTPUT
     452                                           | CODEC_F00_0C_CAP_HP
     453                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT
     454                                           | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     455                                           | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x173f;
    441456            pNode->node.au32F02_param[0] = 0x2;
    442             pNode->port.u32F07_param =   CODEC_F07_IN_ENABLE
    443                                        | CODEC_F07_OUT_ENABLE;
     457            pNode->port.u32F07_param = CODEC_F07_IN_ENABLE
     458                                     | CODEC_F07_OUT_ENABLE;
    444459            pNode->port.u32F08_param = 0;
    445460            if (!pState->fInReset)
    … …  
    453468            goto port_init;
    454469        case 0xB:
    455             pNode->node.au32F00_param[0xC] =   CODEC_MAKE_F00_0C(0x17)
    456                                              | CODEC_F00_0C_CAP_INPUT
    457                                              | CODEC_F00_0C_CAP_OUTPUT
    458                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    459                                              | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    460                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
     470            pNode->node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
     471                                           | CODEC_F00_0C_CAP_INPUT
     472                                           | CODEC_F00_0C_CAP_OUTPUT
     473                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT
     474                                           | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     475                                           | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
    461476            pNode->node.au32F02_param[0] = 0x4;
    462477            pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
    … …  
    472487        case 0xC:
    473488            pNode->node.au32F02_param[0] = 0x3;
    474             pNode->node.au32F00_param[0xC] =   CODEC_MAKE_F00_0C(0x17)
    475                                              | CODEC_F00_0C_CAP_INPUT
    476                                              | CODEC_F00_0C_CAP_OUTPUT
    477                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    478                                              | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    479                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
     489            pNode->node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
     490                                           | CODEC_F00_0C_CAP_INPUT
     491                                           | CODEC_F00_0C_CAP_OUTPUT
     492                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT
     493                                           | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     494                                           | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
    480495            pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
    481496            if (!pState->fInReset)
    … …  
    488503            goto port_init;
    489504        case 0xD:
    490             pNode->node.au32F00_param[0xC] =   CODEC_MAKE_F00_0C(0x17)
    491                                              | CODEC_F00_0C_CAP_INPUT
    492                                              | CODEC_F00_0C_CAP_OUTPUT
    493                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    494                                              | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    495                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
     505            pNode->node.au32F00_param[0xC] = CODEC_MAKE_F00_0C(0x17)
     506                                           | CODEC_F00_0C_CAP_INPUT
     507                                           | CODEC_F00_0C_CAP_OUTPUT
     508                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT
     509                                           | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     510                                           | CODEC_F00_0C_CAP_IMPENDANCE_SENSE;//0x1737;
    496511            pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
    497512            pNode->node.au32F02_param[0] = 0x2;
    … …  
    506521            pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(1, CODEC_F09_ANALOG_NA);//RT_BIT(31)|0x7fffffff;
    507522            pNode->port.u32F08_param = 0;
    508             pNode->node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0)
    509                                            | CODEC_F00_09_CAP_CONNECTION_LIST
    510                                            | CODEC_F00_09_CAP_UNSOL
    511                                            | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
     523            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0)
     524                                         | CODEC_F00_09_CAP_CONNECTION_LIST
     525                                         | CODEC_F00_09_CAP_UNSOL
     526                                         | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
    512527            pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 1);//0x1;
    513         break;
     528            break;
    514529        case 0xE:
    515             pNode->node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0)
    516                                            | CODEC_F00_09_CAP_UNSOL
    517                                            | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(7)|RT_BIT(0);
     530            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0)
     531                                         | CODEC_F00_09_CAP_UNSOL
     532                                         | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(7)|RT_BIT(0);
    518533            pNode->port.u32F08_param = 0;
    519             pNode->node.au32F00_param[0xC] =   CODEC_F00_0C_CAP_INPUT
    520                                              | CODEC_F00_0C_CAP_OUTPUT
    521                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT;//0x34;
     534            pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
     535                                           | CODEC_F00_0C_CAP_OUTPUT
     536                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT;//0x34;
    522537            pNode->port.u32F07_param = CODEC_F07_IN_ENABLE;
    523538            pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(0, CODEC_F09_ANALOG_NA);//0x7fffffff;
    … …  
    531546            break;
    532547        case 0xF:
    533             pNode->node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0x0)
    534                                            | CODEC_F00_09_CAP_CONNECTION_LIST
    535                                            | CODEC_F00_09_CAP_UNSOL
    536                                            | CODEC_F00_09_CAP_OUT_AMP_PRESENT
    537                                            | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(2)|RT_BIT(0);
    538             pNode->node.au32F00_param[0xC] =   CODEC_F00_0C_CAP_INPUT
    539                                              | CODEC_F00_0C_CAP_OUTPUT
    540                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT
    541                                              /* | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
    542                                              | CODEC_F00_0C_CAP_IMPENDANCE_SENSE */;//0x37;
     548            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0x0)
     549                                         | CODEC_F00_09_CAP_CONNECTION_LIST
     550                                         | CODEC_F00_09_CAP_UNSOL
     551                                         | CODEC_F00_09_CAP_OUT_AMP_PRESENT
     552                                         | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(2)|RT_BIT(0);
     553            pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT
     554                                           | CODEC_F00_0C_CAP_OUTPUT
     555                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT
     556                                           /* | CODEC_F00_0C_CAP_TRIGGER_REQUIRED
     557                                           | CODEC_F00_0C_CAP_IMPENDANCE_SENSE */;//0x37;
    543558            pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 1);//0x1;
    544559            pNode->port.u32F08_param = 0;
    545             pNode->port.u32F07_param =   CODEC_F07_OUT_ENABLE
    546                                          | CODEC_F07_IN_ENABLE;
     560            pNode->port.u32F07_param = CODEC_F07_OUT_ENABLE
     561                                     | CODEC_F07_IN_ENABLE;
    547562            if (!pState->fInReset)
    548563                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    … …  
    554569            pNode->node.au32F02_param[0] = 0x5;
    555570            pNode->port.u32F09_param = CODEC_MAKE_F09_ANALOG(0, CODEC_F09_ANALOG_NA);//0x7fffffff;
    556         break;
     571            break;
    557572        case 0x10:
    558573            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0x0, 0x0)
    559                                            | CODEC_F00_09_CAP_DIGITAL
    560                                            | CODEC_F00_09_CAP_CONNECTION_LIST
    561                                            | CODEC_F00_09_CAP_LSB;//(4<<20)|RT_BIT(9)|RT_BIT(8)|RT_BIT(0);
     574                                         | CODEC_F00_09_CAP_DIGITAL
     575                                         | CODEC_F00_09_CAP_CONNECTION_LIST
     576                                         | CODEC_F00_09_CAP_LSB;//(4<<20)|RT_BIT(9)|RT_BIT(8)|RT_BIT(0);
    562577            pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_OUTPUT;//RT_BIT(4);
    563578            pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 0x3);
    … …  
    570585                                                            CODEC_F1C_COLOR_BLACK,
    571586                                                            0x0, 0x3, 0x0);//RT_MAKE_U32_FROM_U8(0x30, 0x10, 0x45, 0x01);
    572         break;
     587            break;
    573588        case 0x11:
    574             pNode->node.au32F00_param[9] = (4 << 20)|(3<<16)|RT_BIT(10)|RT_BIT(9)|RT_BIT(7)|RT_BIT(0);
    575             pNode->node.au32F00_param[0xC] =   CODEC_F00_0C_CAP_EAPD
    576                                              | CODEC_F00_0C_CAP_INPUT
    577                                              | CODEC_F00_0C_CAP_PRESENSE_DETECT;//RT_BIT(16)| RT_BIT(5)|RT_BIT(2);
     589            pNode->node.au32F00_param[9] = (4 << 20) | (3 << 16) | RT_BIT(10) | RT_BIT(9) | RT_BIT(7) | RT_BIT(0);
     590            pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_EAPD
     591                                           | CODEC_F00_0C_CAP_INPUT
     592                                           | CODEC_F00_0C_CAP_PRESENSE_DETECT;//RT_BIT(16)| RT_BIT(5)|RT_BIT(2);
    578593            pNode->digin.u32F05_param = CODEC_MAKE_F05(0, 0, 0, CODEC_F05_D3, CODEC_F05_D3);//0x3 << 4 | 0x3; /* PS-Act: D3 -> D3 */
    579594            pNode->digin.u32F07_param = 0;
    … …  
    588603                                                           CODEC_F1C_COLOR_BLACK,
    589604                                                           0x0, 0x6, 0x0);//(0x1 << 24) | (0xc5 << 16) | (0x10 << 8) | 0x60;
    590         break;
     605            break;
    591606        case 0x12:
    592607            pNode->adcmux.u32F01_param = 0;
    … …  
    595610            pNode->adcmux.u32F01_param = 1;
    596611            adcmux_init:
    597             pNode->node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0x0, 0)
    598                                            | CODEC_F00_09_CAP_CONNECTION_LIST
    599                                            | CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
    600                                            | CODEC_F00_09_CAP_OUT_AMP_PRESENT
    601                                            | CODEC_F00_09_CAP_LSB;//(3<<20)|RT_BIT(8)|RT_BIT(3)|RT_BIT(2)|RT_BIT(0);
     612            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0x0, 0)
     613                                         | CODEC_F00_09_CAP_CONNECTION_LIST
     614                                         | CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
     615                                         | CODEC_F00_09_CAP_OUT_AMP_PRESENT
     616                                         | CODEC_F00_09_CAP_LSB;//(3<<20)|RT_BIT(8)|RT_BIT(3)|RT_BIT(2)|RT_BIT(0);
    602617            pNode->node.au32F00_param[0xe] = CODEC_MAKE_F00_0E(0, 0x7);
    603618            pNode->node.au32F00_param[0x12] = (0x27 << 16)|(0x4 << 8);
    … …  
    606621            pNode->node.au32F02_param[0] = RT_MAKE_U32_FROM_U8(0xe, 0x15, 0xf, 0xb);
    607622            pNode->node.au32F02_param[4] = RT_MAKE_U32_FROM_U8(0xc, 0xd, 0xa, 0x0);
    608         break;
     623            break;
    609624        case 0x14:
    610             pNode->node.au32F00_param[9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_BEEP_GEN, 0, 0)
    611                                            | CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
    612                                            | CODEC_F00_09_CAP_OUT_AMP_PRESENT;//(7 << 20) | RT_BIT(3) | RT_BIT(2);
     625            pNode->node.au32F00_param[9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_BEEP_GEN, 0, 0)
     626                                         | CODEC_F00_09_CAP_AMP_FMT_OVERRIDE
     627                                         | CODEC_F00_09_CAP_OUT_AMP_PRESENT;//(7 << 20) | RT_BIT(3) | RT_BIT(2);
    613628            pNode->node.au32F00_param[0x12] = (0x17 << 16)|(0x3 << 8)| 0x3;
    614629            pNode->pcbeep.u32F0a_param = 0;
    615630            memset(pNode->pcbeep.B_params, 0, AMPLIFIER_SIZE);
    616         break;
     631            break;
    617632        case 0x15:
    618             pNode->node.au32F00_param[0x9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
    619                                              | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(0);
     633            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
     634                                           | CODEC_F00_09_CAP_LSB;//(4 << 20)|RT_BIT(0);
    620635            pNode->node.au32F00_param[0xc] = CODEC_F00_0C_CAP_INPUT;//RT_BIT(5);
    621636            if (!pState->fInReset)
    … …  
    626641                                                            CODEC_F1C_COLOR_UNKNOWN,
    627642                                                            0x0, 0x7, 0x0);//RT_MAKE_U32_FROM_U8(0x70, 0x0, 0x33, 0x90);
    628         break;
     643            break;
    629644        case 0x16:
    630645            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_VOLUME_KNOB, 0x0, 0x0);//(0x6 << 20);
    … …  
    634649            pNode->volumeKnob.u32F08_param = 0;
    635650            pNode->volumeKnob.u32F0f_param = 0x7f;
    636         break;
     651            break;
    637652        case 0x17:
    638653            pNode->node.au32F02_param[0] = 0x12;
    … …  
    643658            memset(pNode->adcvol.B_params, 0, AMPLIFIER_SIZE);
    644659
    645             pNode->node.au32F00_param[0x9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0, 0)
    646                                              | CODEC_F00_09_CAP_L_R_SWAP
    647                                              | CODEC_F00_09_CAP_CONNECTION_LIST
    648                                              | CODEC_F00_09_CAP_IN_AMP_PRESENT
    649                                              | CODEC_F00_09_CAP_LSB;//(0x3 << 20)|RT_BIT(11)|RT_BIT(8)|RT_BIT(1)|RT_BIT(0);
     660            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_SELECTOR, 0, 0)
     661                                           | CODEC_F00_09_CAP_L_R_SWAP
     662                                           | CODEC_F00_09_CAP_CONNECTION_LIST
     663                                           | CODEC_F00_09_CAP_IN_AMP_PRESENT
     664                                           | CODEC_F00_09_CAP_LSB;//(0x3 << 20)|RT_BIT(11)|RT_BIT(8)|RT_BIT(1)|RT_BIT(0);
    650665            pNode->node.au32F00_param[0xe] = CODEC_MAKE_F00_0E(0, 0x1);
    651666            AMPLIFIER_REGISTER(pNode->adcvol.B_params, AMPLIFIER_IN, AMPLIFIER_LEFT, 0) = RT_BIT(7);
    … …  
    654669            break;
    655670        case 0x19:
    656             pNode->node.au32F00_param[0x9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_VENDOR_DEFINED, 0x3, 0)
    657                                              | CODEC_F00_09_CAP_DIGITAL
    658                                              | CODEC_F00_09_CAP_LSB;//(0xF << 20)|(0x3 << 16)|RT_BIT(9)|RT_BIT(0);
     671            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_VENDOR_DEFINED, 0x3, 0)
     672                                           | CODEC_F00_09_CAP_DIGITAL
     673                                           | CODEC_F00_09_CAP_LSB;//(0xF << 20)|(0x3 << 16)|RT_BIT(9)|RT_BIT(0);
    659674            break;
    660675        case 0x1A:
    661             pNode->node.au32F00_param[0x9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0x3, 0)
    662                                              | CODEC_F00_09_CAP_DIGITAL
    663                                              | CODEC_F00_09_CAP_LSB;//(0x3 << 16)|RT_BIT(9)|RT_BIT(0);
     676            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_AUDIO_OUTPUT, 0x3, 0)
     677                                           | CODEC_F00_09_CAP_DIGITAL
     678                                           | CODEC_F00_09_CAP_LSB;//(0x3 << 16)|RT_BIT(9)|RT_BIT(0);
    664679            break;
    665680        case 0x1B:
    666             pNode->node.au32F00_param[0x9] =   CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
    667                                              | CODEC_F00_09_CAP_DIGITAL
    668                                              | CODEC_F00_09_CAP_CONNECTION_LIST
    669                                              | CODEC_F00_09_CAP_LSB;//(0x4 << 20)|RT_BIT(9)|RT_BIT(8)|RT_BIT(0);
     681            pNode->node.au32F00_param[0x9] = CODEC_MAKE_F00_09(CODEC_F00_09_TYPE_PIN_COMPLEX, 0, 0)
     682                                           | CODEC_F00_09_CAP_DIGITAL
     683                                           | CODEC_F00_09_CAP_CONNECTION_LIST
     684                                           | CODEC_F00_09_CAP_LSB;//(0x4 << 20)|RT_BIT(9)|RT_BIT(8)|RT_BIT(0);
    670685            pNode->node.au32F00_param[0xE] = CODEC_MAKE_F00_0E(0, 0x1);
    671686            pNode->node.au32F00_param[0xC] = CODEC_F00_0C_CAP_OUTPUT;//0x10;
    … …  
    687702
    688703#define DECLISNODEOFTYPE(type)                                                                  \
    689     static inline int codecIs##type##Node(struct CODECState *pState, uint8_t cNode)             \
     704    DECLINLINE(int) hdaCodecIs##type##Node(PHDACODEC pState, uint8_t cNode)                     \
    690705    {                                                                                           \
    691706        Assert(pState->au8##type##s);                                                           \
    692         for(int i = 0; pState->au8##type##s[i] != 0; ++i)                                       \
     707        for (int i = 0; pState->au8##type##s[i] != 0; ++i)                                      \
    693708            if (pState->au8##type##s[i] == cNode)                                               \
    694709                return 1;                                                                       \
    695710        return 0;                                                                               \
    696711    }
    697 /* codecIsPortNode */
     712/* hdaCodecIsPortNode */
    698713DECLISNODEOFTYPE(Port)
    699 /* codecIsDacNode */
     714/* hdaCodecIsDacNode */
    700715DECLISNODEOFTYPE(Dac)
    701 /* codecIsAdcVolNode */
     716/* hdaCodecIsAdcVolNode */
    702717DECLISNODEOFTYPE(AdcVol)
    703 /* codecIsAdcNode */
     718/* hdaCodecIsAdcNode */
    704719DECLISNODEOFTYPE(Adc)
    705 /* codecIsAdcMuxNode */
     720/* hdaCodecIsAdcMuxNode */
    706721DECLISNODEOFTYPE(AdcMux)
    707 /* codecIsPcbeepNode */
     722/* hdaCodecIsPcbeepNode */
    708723DECLISNODEOFTYPE(Pcbeep)
    709 /* codecIsSpdifOutNode */
     724/* hdaCodecIsSpdifOutNode */
    710725DECLISNODEOFTYPE(SpdifOut)
    711 /* codecIsSpdifInNode */
     726/* hdaCodecIsSpdifInNode */
    712727DECLISNODEOFTYPE(SpdifIn)
    713 /* codecIsDigInPinNode */
     728/* hdaCodecIsDigInPinNode */
    714729DECLISNODEOFTYPE(DigInPin)
    715 /* codecIsDigOutPinNode */
     730/* hdaCodecIsDigOutPinNode */
    716731DECLISNODEOFTYPE(DigOutPin)
    717 /* codecIsCdNode */
     732/* hdaCodecIsCdNode */
    718733DECLISNODEOFTYPE(Cd)
    719 /* codecIsVolKnobNode */
     734/* hdaCodecIsVolKnobNode */
    720735DECLISNODEOFTYPE(VolKnob)
    721 /* codecIsReservedNode */
     736/* hdaCodecIsReservedNode */
    722737DECLISNODEOFTYPE(Reserved)
    723738
    724 static int codecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt);
    725 
    726 static inline void codecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
    727 {
    728         Assert((pu32Reg && u8Offset < 32));
    729         *pu32Reg &= ~(mask << u8Offset);
    730         *pu32Reg |= (u32Cmd & mask) << u8Offset;
    731 }
    732 static inline void codecSetRegisterU8(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
    733 {
    734     codecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_8BIT_DATA);
    735 }
    736 
    737 static inline void codecSetRegisterU16(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
    738 {
    739     codecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_16BIT_DATA);
    740 }
    741 
    742 
    743 static int codecUnimplemented(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    744 {
    745     Log(("codecUnimplemented: cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
     739static int hdaCodecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt);
     740
     741DECLINLINE(void) hdaCodecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
     742{
     743    Assert((pu32Reg && u8Offset < 32));
     744    *pu32Reg &= ~(mask << u8Offset);
     745    *pu32Reg |= (u32Cmd & mask) << u8Offset;
     746}
     747DECLINLINE(void) hdaCodecSetRegisterU8(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
     748{
     749    hdaCodecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_8BIT_DATA);
     750}
     751
     752DECLINLINE(void) hdaCodecSetRegisterU16(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
     753{
     754    hdaCodecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_16BIT_DATA);
     755}
     756
     757
     758/*
     759 * Verb processor functions.
     760 */
     761
     762static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     763{
     764    Log(("vrbProcUnimplemented: cmd(raw:%x: cad:%x, d:%c, nid:%x, verb:%x)\n", cmd,
    746765        CODEC_CAD(cmd), CODEC_DIRECT(cmd) ? 'N' : 'Y', CODEC_NID(cmd), CODEC_VERBDATA(cmd)));
    747766    *pResp = 0;
    … …  
    749768}
    750769
    751 static int codecBreak(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     770static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    752771{
    753772    int rc;
    754     rc = codecUnimplemented(pState, cmd, pResp);
     773    rc = vrbProcUnimplemented(pState, cmd, pResp);
    755774    *pResp |= CODEC_RESPONSE_UNSOLICITED;
    756775    return rc;
    757776}
     777
    758778/* B-- */
    759 static int codecGetAmplifier(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    760 {
    761     Assert((CODEC_CAD(cmd) == pState->id));
    762     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    763     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    764     {
    765         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     779static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     780{
     781    Assert((CODEC_CAD(cmd) == pState->id));
     782    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     783    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     784    {
     785        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    766786        return VINF_SUCCESS;
    767787    }
    … …  
    772792
    773793    PCODECNODE pNode = &pState->paNodes[CODEC_NID(cmd)];
    774     if (codecIsDacNode(pState, CODEC_NID(cmd)))
     794    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    775795        *pResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
    776796                            CODEC_GET_AMP_DIRECTION(cmd),
    777797                            CODEC_GET_AMP_SIDE(cmd),
    778798                            u8Index);
    779     else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     799    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    780800        *pResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
    781801                            CODEC_GET_AMP_DIRECTION(cmd),
    782802                            CODEC_GET_AMP_SIDE(cmd),
    783803                            u8Index);
    784     else if (codecIsAdcMuxNode(pState, CODEC_NID(cmd)))
     804    else if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
    785805        *pResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
    786806                            CODEC_GET_AMP_DIRECTION(cmd),
    787807                            CODEC_GET_AMP_SIDE(cmd),
    788808                            u8Index);
    789     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     809    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    790810        *pResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
    791811                            CODEC_GET_AMP_DIRECTION(cmd),
    792812                            CODEC_GET_AMP_SIDE(cmd),
    793813                            u8Index);
    794     else if (codecIsPortNode(pState, CODEC_NID(cmd)))
     814    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    795815        *pResp = AMPLIFIER_REGISTER(pNode->port.B_params,
    796816                            CODEC_GET_AMP_DIRECTION(cmd),
    797817                            CODEC_GET_AMP_SIDE(cmd),
    798818                            u8Index);
    799     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     819    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    800820        *pResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
    801821                            CODEC_GET_AMP_DIRECTION(cmd),
    … …  
    807827    return VINF_SUCCESS;
    808828}
     829
    809830/* 3-- */
    810 static int codecSetAmplifier(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     831static DECLCALLBACK(int) vrbProcSetAmplifier(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    811832{
    812833    AMPLIFIER *pAmplifier = NULL;
    … …  
    819840    if (CODEC_NID(cmd) >= pState->cTotalNodes)
    820841    {
    821         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     842        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    822843        return VINF_SUCCESS;
    823844    }
    824845    *pResp = 0;
    825846    PCODECNODE pNode = &pState->paNodes[CODEC_NID(cmd)];
    826     if (codecIsDacNode(pState, CODEC_NID(cmd)))
     847    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    827848        pAmplifier = &pNode->dac.B_params;
    828     else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     849    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    829850        pAmplifier = &pNode->adcvol.B_params;
    830     else if (codecIsAdcMuxNode(pState, CODEC_NID(cmd)))
     851    else if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
    831852        pAmplifier = &pNode->adcmux.B_params;
    832     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     853    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    833854        pAmplifier = &pNode->pcbeep.B_params;
    834     else if (codecIsPortNode(pState, CODEC_NID(cmd)))
     855    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    835856        pAmplifier = &pNode->port.B_params;
    836     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     857    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    837858        pAmplifier = &pNode->adc.B_params;
    838859    Assert(pAmplifier);
    … …  
    850871        {
    851872            if (fIsLeft)
    852                 codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
     873                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
    853874            if (fIsRight)
    854                 codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
     875                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    855876        }
    856877        if (fIsOut)
    857878        {
    858879            if (fIsLeft)
    859                 codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
     880                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
    860881            if (fIsRight)
    861                 codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
     882                hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    862883        }
    863884        if (CODEC_NID(cmd) == pState->u8DacLineOut)
    864             codecToAudVolume(pAmplifier, AUD_MIXER_VOLUME);
     885            hdaCodecToAudVolume(pAmplifier, AUD_MIXER_VOLUME);
    865886        if (CODEC_NID(cmd) == pState->u8AdcVolsLineIn) /* Microphone */
    866             codecToAudVolume(pAmplifier, AUD_MIXER_LINE_IN);
    867     }
    868     return VINF_SUCCESS;
    869 }
    870 
    871 static int codecGetParameter(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    872 {
    873     Assert((CODEC_CAD(cmd) == pState->id));
    874     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    875     {
    876         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    877         return VINF_SUCCESS;
    878     }
    879     Assert(((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F0_PARAM_LENGTH));
    880     if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F0_PARAM_LENGTH)
    881     {
    882         Log(("HDAcodec: invalid F00 parameter %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
     887            hdaCodecToAudVolume(pAmplifier, AUD_MIXER_LINE_IN);
     888    }
     889    return VINF_SUCCESS;
     890}
     891
     892static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     893{
     894    Assert(CODEC_CAD(cmd) == pState->id);
     895    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     896    {
     897        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     898        return VINF_SUCCESS;
     899    }
     900    Assert((cmd & CODEC_VERB_8BIT_DATA) < CODECNODE_F00_PARAM_LENGTH);
     901    if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F00_PARAM_LENGTH)
     902    {
     903        Log(("HdaCodec: invalid F00 parameter %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
    883904        return VINF_SUCCESS;
    884905    }
    … …  
    889910
    890911/* F01 */
    891 static int codecGetConSelectCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    892 {
    893     Assert((CODEC_CAD(cmd) == pState->id));
    894     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    895     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    896     {
    897         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    898         return VINF_SUCCESS;
    899     }
    900     *pResp = 0;
    901     if (codecIsAdcMuxNode(pState, CODEC_NID(cmd)))
     912static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     913{
     914    Assert(CODEC_CAD(cmd) == pState->id);
     915    Assert(CODEC_NID(cmd) < pState->cTotalNodes);
     916    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     917    {
     918        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     919        return VINF_SUCCESS;
     920    }
     921    *pResp = 0;
     922    if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
    902923        *pResp = pState->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
    903     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     924    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    904925        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
    905     else if (codecIsPortNode(pState, CODEC_NID(cmd)))
     926    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    906927        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F01_param;
    907     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     928    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    908929        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
    909     else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     930    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    910931        *pResp = pState->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
    911932    return VINF_SUCCESS;
    … …  
    913934
    914935/* 701 */
    915 static int codecSetConSelectCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     936static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    916937{
    917938    uint32_t *pu32Reg = NULL;
    … …  
    919940    if (CODEC_NID(cmd) >= pState->cTotalNodes)
    920941    {
    921         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    922         return VINF_SUCCESS;
    923     }
    924     *pResp = 0;
    925     if (codecIsAdcMuxNode(pState, CODEC_NID(cmd)))
     942        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     943        return VINF_SUCCESS;
     944    }
     945    *pResp = 0;
     946    if (hdaCodecIsAdcMuxNode(pState, CODEC_NID(cmd)))
    926947        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcmux.u32F01_param;
    927     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     948    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    928949        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F01_param;
    929     else if (codecIsPortNode(pState, CODEC_NID(cmd)))
     950    else if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    930951        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F01_param;
    931     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     952    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    932953        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adc.u32F01_param;
    933     else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     954    else if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    934955        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
    935956    Assert((pu32Reg));
    936957    if (pu32Reg)
    937         codecSetRegisterU8(pu32Reg, cmd, 0);
     958        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    938959    return VINF_SUCCESS;
    939960}
    940961
    941962/* F07 */
    942 static int codecGetPinCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    943 {
    944     Assert((CODEC_CAD(cmd) == pState->id));
    945     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    946     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    947     {
    948         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    949         return VINF_SUCCESS;
    950     }
    951     *pResp = 0;
    952     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     963static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     964{
     965    Assert((CODEC_CAD(cmd) == pState->id));
     966    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     967    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     968    {
     969        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     970        return VINF_SUCCESS;
     971    }
     972    *pResp = 0;
     973    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    953974        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F07_param;
    954     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     975    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    955976        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
    956     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     977    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    957978        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
    958     else if (codecIsCdNode(pState, CODEC_NID(cmd)))
     979    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
    959980        *pResp = pState->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
    960     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     981    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    961982        *pResp = pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
    962     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     983    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    963984        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
    964985    else
    … …  
    968989
    969990/* 707 */
    970 static int codecSetPinCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    971 {
    972     Assert((CODEC_CAD(cmd) == pState->id));
    973     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    974     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    975     {
    976         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     991static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     992{
     993    Assert((CODEC_CAD(cmd) == pState->id));
     994    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     995    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     996    {
     997        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    977998        return VINF_SUCCESS;
    978999    }
    9791000    *pResp = 0;
    9801001    uint32_t *pu32Reg = NULL;
    981     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1002    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    9821003        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F07_param;
    983     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1004    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    9841005        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F07_param;
    985     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1006    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    9861007        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F07_param;
    987     else if (codecIsCdNode(pState, CODEC_NID(cmd)))
     1008    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
    9881009        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
    989     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1010    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    9901011        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
    991     else if (   codecIsReservedNode(pState, CODEC_NID(cmd))
     1012    else if (   hdaCodecIsReservedNode(pState, CODEC_NID(cmd))
    9921013             && CODEC_NID(cmd) == 0x1b)
    9931014        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F07_param;
    9941015    Assert((pu32Reg));
    9951016    if (pu32Reg)
    996         codecSetRegisterU8(pu32Reg, cmd, 0);
     1017        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    9971018    return VINF_SUCCESS;
    9981019}
    9991020
    10001021/* F08 */
    1001 static int codecGetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1002 {
    1003     Assert((CODEC_CAD(cmd) == pState->id));
    1004     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1005     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1006     {
    1007         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1008         return VINF_SUCCESS;
    1009     }
    1010     *pResp = 0;
    1011     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1022static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1023{
     1024    Assert((CODEC_CAD(cmd) == pState->id));
     1025    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1026    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1027    {
     1028        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1029        return VINF_SUCCESS;
     1030    }
     1031    *pResp = 0;
     1032    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    10121033        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F08_param;
    1013     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1034    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10141035        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
    10151036    else if ((cmd) == 1 /* AFG */)
    10161037        *pResp = pState->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
    1017     else if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
     1038    else if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
    10181039        *pResp = pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
    1019     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1040    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    10201041        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
    1021     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1042    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10221043        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
    10231044    else
    … …  
    10271048
    10281049/* 708 */
    1029 static int codecSetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1030 {
    1031     Assert((CODEC_CAD(cmd) == pState->id));
    1032     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1033     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1034     {
    1035         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1050static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1051{
     1052    Assert((CODEC_CAD(cmd) == pState->id));
     1053    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1054    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1055    {
     1056        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    10361057        return VINF_SUCCESS;
    10371058    }
    10381059    *pResp = 0;
    10391060    uint32_t *pu32Reg = NULL;
    1040     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1061    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    10411062        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F08_param;
    1042     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1063    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10431064        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
    10441065    else if (CODEC_NID(cmd) == 1 /* AFG */)
    10451066        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].afg.u32F08_param;
    1046     else if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
     1067    else if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
    10471068        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
    1048     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1069    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10491070        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F08_param;
    1050     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1071    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    10511072        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F08_param;
    10521073    else
    … …  
    10541075    Assert(pu32Reg);
    10551076    if(pu32Reg)
    1056         codecSetRegisterU8(pu32Reg, cmd, 0);
     1077        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    10571078    return VINF_SUCCESS;
    10581079}
    10591080
    10601081/* F09 */
    1061 static int codecGetPinSense(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1062 {
    1063     Assert((CODEC_CAD(cmd) == pState->id));
    1064     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1065     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1066     {
    1067         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1068         return VINF_SUCCESS;
    1069     }
    1070     *pResp = 0;
    1071     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1082static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1083{
     1084    Assert((CODEC_CAD(cmd) == pState->id));
     1085    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1086    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1087    {
     1088        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1089        return VINF_SUCCESS;
     1090    }
     1091    *pResp = 0;
     1092    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    10721093        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F09_param;
    1073     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1094    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10741095        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
    10751096    else
    … …  
    10791100
    10801101/* 709 */
    1081 static int codecSetPinSense(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1082 {
    1083     Assert((CODEC_CAD(cmd) == pState->id));
    1084     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1085     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1086     {
    1087         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1102static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1103{
     1104    Assert((CODEC_CAD(cmd) == pState->id));
     1105    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1106    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1107    {
     1108        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    10881109        return VINF_SUCCESS;
    10891110    }
    10901111    *pResp = 0;
    10911112    uint32_t *pu32Reg = NULL;
    1092     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1113    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    10931114        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F09_param;
    1094     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1115    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    10951116        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F09_param;
    10961117    Assert(pu32Reg);
    10971118    if(pu32Reg)
    1098         codecSetRegisterU8(pu32Reg, cmd, 0);
    1099     return VINF_SUCCESS;
    1100 }
    1101 
    1102 static int codecGetConnectionListEntry(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1103 {
    1104     Assert((CODEC_CAD(cmd) == pState->id));
    1105     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1106     *pResp = 0;
    1107     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1108     {
    1109         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1119        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
     1120    return VINF_SUCCESS;
     1121}
     1122
     1123static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1124{
     1125    Assert((CODEC_CAD(cmd) == pState->id));
     1126    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1127    *pResp = 0;
     1128    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1129    {
     1130        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    11101131        return VINF_SUCCESS;
    11111132    }
    … …  
    11131134    if ((cmd & CODEC_VERB_8BIT_DATA) >= CODECNODE_F02_PARAM_LENGTH)
    11141135    {
    1115         Log(("HDAcodec: access to invalid F02 index %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
     1136        Log(("HdaCodec: access to invalid F02 index %d\n", (cmd & CODEC_VERB_8BIT_DATA)));
    11161137        return VINF_SUCCESS;
    11171138    }
    … …  
    11191140    return VINF_SUCCESS;
    11201141}
     1142
    11211143/* F03 */
    1122 static int codecGetProcessingState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1123 {
    1124     Assert((CODEC_CAD(cmd) == pState->id));
    1125     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1126     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1127     {
    1128         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1129         return VINF_SUCCESS;
    1130     }
    1131     *pResp = 0;
    1132     if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1144static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1145{
     1146    Assert((CODEC_CAD(cmd) == pState->id));
     1147    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1148    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1149    {
     1150        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1151        return VINF_SUCCESS;
     1152    }
     1153    *pResp = 0;
     1154    if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    11331155        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F03_param;
    11341156    return VINF_SUCCESS;
    … …  
    11361158
    11371159/* 703 */
    1138 static int codecSetProcessingState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1139 {
    1140     Assert((CODEC_CAD(cmd) == pState->id));
    1141     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1142     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1143     {
    1144         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1145         return VINF_SUCCESS;
    1146     }
    1147     *pResp = 0;
    1148     if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    1149     {
    1150         codecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
     1160static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1161{
     1162    Assert((CODEC_CAD(cmd) == pState->id));
     1163    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1164    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1165    {
     1166        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1167        return VINF_SUCCESS;
     1168    }
     1169    *pResp = 0;
     1170    if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
     1171    {
     1172        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
    11511173    }
    11521174    return VINF_SUCCESS;
    … …  
    11541176
    11551177/* F0D */
    1156 static int codecGetDigitalConverter(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1157 {
    1158     Assert((CODEC_CAD(cmd) == pState->id));
    1159     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1160     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1161     {
    1162         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1163         return VINF_SUCCESS;
    1164     }
    1165     *pResp = 0;
    1166     if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1178static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1179{
     1180    Assert((CODEC_CAD(cmd) == pState->id));
     1181    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1182    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1183    {
     1184        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1185        return VINF_SUCCESS;
     1186    }
     1187    *pResp = 0;
     1188    if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    11671189        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param;
    1168     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1190    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    11691191        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param;
    11701192    return VINF_SUCCESS;
    11711193}
    11721194
    1173 static int codecSetDigitalConverter(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
    1174 {
    1175     Assert((CODEC_CAD(cmd) == pState->id));
    1176     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1177     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1178     {
    1179         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1180         return VINF_SUCCESS;
    1181     }
    1182     *pResp = 0;
    1183     if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    1184         codecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
    1185     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
    1186         codecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
     1195static int codecSetDigitalConverter(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
     1196{
     1197    Assert((CODEC_CAD(cmd) == pState->id));
     1198    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1199    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1200    {
     1201        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1202        return VINF_SUCCESS;
     1203    }
     1204    *pResp = 0;
     1205    if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1206        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
     1207    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1208        hdaCodecSetRegisterU8(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
    11871209    return VINF_SUCCESS;
    11881210}
    11891211
    11901212/* 70D */
    1191 static int codecSetDigitalConverter1(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1213static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    11921214{
    11931215    return codecSetDigitalConverter(pState, cmd, 0, pResp);
    … …  
    11951217
    11961218/* 70E */
    1197 static int codecSetDigitalConverter2(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1219static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    11981220{
    11991221    return codecSetDigitalConverter(pState, cmd, 8, pResp);
    … …  
    12011223
    12021224/* F20 */
    1203 static int codecGetSubId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1204 {
    1205     Assert((CODEC_CAD(cmd) == pState->id));
    1206     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1207     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1208     {
    1209         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1225static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1226{
     1227    Assert((CODEC_CAD(cmd) == pState->id));
     1228    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1229    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1230    {
     1231        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    12101232        return VINF_SUCCESS;
    12111233    }
    … …  
    12181240}
    12191241
    1220 static int codecSetSubIdX(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset)
    1221 {
    1222     Assert((CODEC_CAD(cmd) == pState->id));
    1223     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1224     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1225     {
    1226         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1242static int codecSetSubIdX(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset)
     1243{
     1244    Assert((CODEC_CAD(cmd) == pState->id));
     1245    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1246    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1247    {
     1248        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    12271249        return VINF_SUCCESS;
    12281250    }
    … …  
    12321254    Assert((pu32Reg));
    12331255    if (pu32Reg)
    1234         codecSetRegisterU8(pu32Reg, cmd, u8Offset);
    1235     return VINF_SUCCESS;
    1236 }
     1256        hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
     1257    return VINF_SUCCESS;
     1258}
     1259
    12371260/* 720 */
    1238 static int codecSetSubId0 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1261static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    12391262{
    12401263    *pResp = 0;
    … …  
    12431266
    12441267/* 721 */
    1245 static int codecSetSubId1 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1268static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    12461269{
    12471270    *pResp = 0;
    12481271    return codecSetSubIdX(pState, cmd, 8);
    12491272}
     1273
    12501274/* 722 */
    1251 static int codecSetSubId2 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1275static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    12521276{
    12531277    *pResp = 0;
    12541278    return codecSetSubIdX(pState, cmd, 16);
    12551279}
     1280
    12561281/* 723 */
    1257 static int codecSetSubId3 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1282static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    12581283{
    12591284    *pResp = 0;
    … …  
    12611286}
    12621287
    1263 static int codecReset(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1288static DECLCALLBACK(int) vrbProcReset(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    12641289{
    12651290    Assert((CODEC_CAD(cmd) == pState->id));
    … …  
    12691294    {
    12701295        uint8_t i;
    1271         Log(("HDAcodec: enters reset\n"));
     1296        Log(("HdaCodec: enters reset\n"));
    12721297        Assert(pState->pfnCodecNodeReset);
    12731298        for (i = 0; i < pState->cTotalNodes; ++i)
    … …  
    12761301        }
    12771302        pState->fInReset = false;
    1278         Log(("HDAcodec: exits reset\n"));
     1303        Log(("HdaCodec: exits reset\n"));
    12791304    }
    12801305    *pResp = 0;
    … …  
    12831308
    12841309/* F05 */
    1285 static int codecGetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1286 {
    1287     Assert((CODEC_CAD(cmd) == pState->id));
    1288     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1289     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1290     {
    1291         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1310static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1311{
     1312    Assert((CODEC_CAD(cmd) == pState->id));
     1313    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1314    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1315    {
     1316        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    12921317        return VINF_SUCCESS;
    12931318    }
    … …  
    12951320    if (CODEC_NID(cmd) == 1 /* AFG */)
    12961321        *pResp = pState->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
    1297     else if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1322    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    12981323        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
    1299     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1324    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    13001325        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
    1301     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1326    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    13021327        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
    1303     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1328    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    13041329        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
    1305     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1330    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    13061331        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
    1307     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1332    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    13081333        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
    13091334    return VINF_SUCCESS;
    … …  
    13121337/* 705 */
    13131338
    1314 static inline void codecPropogatePowerState(uint32_t *pu32F05_param)
     1339DECLINLINE(void) codecPropogatePowerState(uint32_t *pu32F05_param)
    13151340{
    13161341    Assert(pu32F05_param);
    … …  
    13231348}
    13241349
    1325 static int codecSetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1326 {
    1327     Assert((CODEC_CAD(cmd) == pState->id));
    1328     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1329     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1330     {
    1331         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1350static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1351{
     1352    Assert((CODEC_CAD(cmd) == pState->id));
     1353    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1354    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1355    {
     1356        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    13321357        return VINF_SUCCESS;
    13331358    }
    … …  
    13361361    if (CODEC_NID(cmd) == 1 /* AFG */)
    13371362        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].afg.u32F05_param;
    1338     else if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1363    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    13391364        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].dac.u32F05_param;
    1340     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1365    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    13411366        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F05_param;
    1342     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1367    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    13431368        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adc.u32F05_param;
    1344     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1369    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    13451370        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
    1346     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1371    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    13471372        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
    1348     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1373    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    13491374        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F05_param;
    13501375    Assert((pu32Reg));
    … …  
    13901415}
    13911416
    1392 static int codecGetStreamId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1393 {
    1394     Assert((CODEC_CAD(cmd) == pState->id));
    1395     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1396     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1397     {
    1398         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1399         return VINF_SUCCESS;
    1400     }
    1401     *pResp = 0;
    1402     if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1417static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1418{
     1419    Assert((CODEC_CAD(cmd) == pState->id));
     1420    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1421    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1422    {
     1423        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1424        return VINF_SUCCESS;
     1425    }
     1426    *pResp = 0;
     1427    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    14031428        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
    1404     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1429    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    14051430        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
    1406     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1431    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    14071432        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
    1408     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1433    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    14091434        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
    14101435    else if (CODEC_NID(cmd) == 0x1A)
    … …  
    14121437    return VINF_SUCCESS;
    14131438}
    1414 static int codecSetStreamId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1415 {
    1416     Assert((CODEC_CAD(cmd) == pState->id));
    1417     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1418     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1419     {
    1420         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1439
     1440static DECLCALLBACK(int) vrbProcSetStreamId(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1441{
     1442    Assert((CODEC_CAD(cmd) == pState->id));
     1443    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1444    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1445    {
     1446        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    14211447        return VINF_SUCCESS;
    14221448    }
    … …  
    14241450    uint32_t *pu32addr = NULL;
    14251451    *pResp = 0;
    1426     if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1452    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    14271453        pu32addr = &pState->paNodes[CODEC_NID(cmd)].dac.u32F06_param;
    1428     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1454    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    14291455        pu32addr = &pState->paNodes[CODEC_NID(cmd)].adc.u32F06_param;
    1430     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1456    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    14311457        pu32addr = &pState->paNodes[CODEC_NID(cmd)].spdifout.u32F06_param;
    1432     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1458    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    14331459        pu32addr = &pState->paNodes[CODEC_NID(cmd)].spdifin.u32F06_param;
    1434     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1460    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    14351461        pu32addr = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F06_param;
    14361462    Assert((pu32addr));
    14371463    if (pu32addr)
    1438         codecSetRegisterU8(pu32addr, cmd, 0);
    1439     return VINF_SUCCESS;
    1440 }
    1441 
    1442 static int codecGetConverterFormat(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1443 {
    1444     Assert((CODEC_CAD(cmd) == pState->id));
    1445     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1446     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1447     {
    1448         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1449         return VINF_SUCCESS;
    1450     }
    1451     *pResp = 0;
    1452     if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1464        hdaCodecSetRegisterU8(pu32addr, cmd, 0);
     1465    return VINF_SUCCESS;
     1466}
     1467
     1468static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1469{
     1470    Assert((CODEC_CAD(cmd) == pState->id));
     1471    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1472    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1473    {
     1474        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1475        return VINF_SUCCESS;
     1476    }
     1477    *pResp = 0;
     1478    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    14531479        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32A_param;
    1454     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
     1480    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
    14551481        *pResp = pState->paNodes[CODEC_NID(cmd)].adc.u32A_param;
    1456     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1482    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    14571483        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifout.u32A_param;
    1458     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1484    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
    14591485        *pResp = pState->paNodes[CODEC_NID(cmd)].spdifin.u32A_param;
    14601486    return VINF_SUCCESS;
    14611487}
    14621488
    1463 static int codecSetConverterFormat(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1464 {
    1465     Assert((CODEC_CAD(cmd) == pState->id));
    1466     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1467     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1468     {
    1469         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1470         return VINF_SUCCESS;
    1471     }
    1472     *pResp = 0;
    1473     if (codecIsDacNode(pState, CODEC_NID(cmd)))
    1474         codecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
    1475     else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    1476         codecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
    1477     else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
    1478         codecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
    1479     else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
    1480         codecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
     1489static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1490{
     1491    Assert((CODEC_CAD(cmd) == pState->id));
     1492    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1493    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1494    {
     1495        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1496        return VINF_SUCCESS;
     1497    }
     1498    *pResp = 0;
     1499    if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
     1500        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
     1501    else if (hdaCodecIsAdcNode(pState, CODEC_NID(cmd)))
     1502        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
     1503    else if (hdaCodecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1504        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
     1505    else if (hdaCodecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1506        hdaCodecSetRegisterU16(&pState->paNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
    14811507    return VINF_SUCCESS;
    14821508}
    14831509
    14841510/* F0C */
    1485 static int codecGetEAPD_BTLEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1486 {
    1487     Assert((CODEC_CAD(cmd) == pState->id));
    1488     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1489     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1490     {
    1491         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1492         return VINF_SUCCESS;
    1493     }
    1494     *pResp = 0;
    1495     if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     1511static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1512{
     1513    Assert((CODEC_CAD(cmd) == pState->id));
     1514    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1515    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1516    {
     1517        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1518        return VINF_SUCCESS;
     1519    }
     1520    *pResp = 0;
     1521    if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    14961522        *pResp = pState->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
    1497     else if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1523    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    14981524        *pResp = pState->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
    1499     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1525    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    15001526        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
    15011527    return VINF_SUCCESS;
    … …  
    15031529
    15041530/* 70C */
    1505 static int codecSetEAPD_BTLEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1506 {
    1507     Assert((CODEC_CAD(cmd) == pState->id));
    1508     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1509     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1510     {
    1511         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1531static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1532{
     1533    Assert((CODEC_CAD(cmd) == pState->id));
     1534    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1535    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1536    {
     1537        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    15121538        return VINF_SUCCESS;
    15131539    }
    15141540    *pResp = 0;
    15151541    uint32_t *pu32Reg = NULL;
    1516     if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     1542    if (hdaCodecIsAdcVolNode(pState, CODEC_NID(cmd)))
    15171543        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].adcvol.u32F0c_param;
    1518     else if (codecIsDacNode(pState, CODEC_NID(cmd)))
     1544    else if (hdaCodecIsDacNode(pState, CODEC_NID(cmd)))
    15191545        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].dac.u32F0c_param;
    1520     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1546    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    15211547        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F0c_param;
    15221548    *pResp = 0;
    15231549    Assert((pu32Reg));
    15241550    if (pu32Reg)
    1525         codecSetRegisterU8(pu32Reg, cmd, 0);
     1551        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    15261552    return VINF_SUCCESS;
    15271553}
    15281554
    15291555/* F0F */
    1530 static int codecGetVolumeKnobCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1531 {
    1532     Assert((CODEC_CAD(cmd) == pState->id));
    1533     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1534     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1535     {
    1536         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1537         return VINF_SUCCESS;
    1538     }
    1539     *pResp = 0;
    1540     if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
     1556static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1557{
     1558    Assert((CODEC_CAD(cmd) == pState->id));
     1559    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1560    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1561    {
     1562        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1563        return VINF_SUCCESS;
     1564    }
     1565    *pResp = 0;
     1566    if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
    15411567        *pResp = pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
    15421568    return VINF_SUCCESS;
    … …  
    15441570
    15451571/* 70F */
    1546 static int codecSetVolumeKnobCtrl(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1547 {
    1548     Assert((CODEC_CAD(cmd) == pState->id));
    1549     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1550     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1551     {
    1552         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1572static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1573{
     1574    Assert((CODEC_CAD(cmd) == pState->id));
     1575    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1576    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1577    {
     1578        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    15531579        return VINF_SUCCESS;
    15541580    }
    15551581    uint32_t *pu32Reg = NULL;
    15561582    *pResp = 0;
    1557     if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
     1583    if (hdaCodecIsVolKnobNode(pState, CODEC_NID(cmd)))
    15581584        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].volumeKnob.u32F0f_param;
    15591585    Assert((pu32Reg));
    15601586    if (pu32Reg)
    1561         codecSetRegisterU8(pu32Reg, cmd, 0);
     1587        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    15621588    return VINF_SUCCESS;
    15631589}
    15641590
    15651591/* F17 */
    1566 static int codecGetGPIOUnsolisted (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1567 {
    1568     Assert((CODEC_CAD(cmd) == pState->id));
    1569     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1570     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1571     {
    1572         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1592static DECLCALLBACK(int) vrbProcGetGPIOUnsolisted(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1593{
     1594    Assert((CODEC_CAD(cmd) == pState->id));
     1595    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1596    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1597    {
     1598        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    15731599        return VINF_SUCCESS;
    15741600    }
    … …  
    15811607
    15821608/* 717 */
    1583 static int codecSetGPIOUnsolisted (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1584 {
    1585     Assert((CODEC_CAD(cmd) == pState->id));
    1586     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1587     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1588     {
    1589         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1609static DECLCALLBACK(int) vrbProcSetGPIOUnsolisted(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1610{
     1611    Assert((CODEC_CAD(cmd) == pState->id));
     1612    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1613    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1614    {
     1615        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    15901616        return VINF_SUCCESS;
    15911617    }
    … …  
    15961622    Assert((pu32Reg));
    15971623    if (pu32Reg)
    1598         codecSetRegisterU8(pu32Reg, cmd, 0);
     1624        hdaCodecSetRegisterU8(pu32Reg, cmd, 0);
    15991625    return VINF_SUCCESS;
    16001626}
    16011627
    16021628/* F1C */
    1603 static int codecGetConfig (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    1604 {
    1605     Assert((CODEC_CAD(cmd) == pState->id));
    1606     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1607     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1608     {
    1609         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    1610         return VINF_SUCCESS;
    1611     }
    1612     *pResp = 0;
    1613     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1629static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
     1630{
     1631    Assert((CODEC_CAD(cmd) == pState->id));
     1632    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1633    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1634    {
     1635        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
     1636        return VINF_SUCCESS;
     1637    }
     1638    *pResp = 0;
     1639    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    16141640        *pResp = pState->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
    1615     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1641    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    16161642        *pResp = pState->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
    1617     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1643    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    16181644        *pResp = pState->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
    1619     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1645    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    16201646        *pResp = pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
    1621     else if (codecIsCdNode(pState, CODEC_NID(cmd)))
     1647    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
    16221648        *pResp = pState->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
    1623     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1649    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    16241650        *pResp = pState->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
    16251651    return VINF_SUCCESS;
    16261652}
    1627 static int codecSetConfigX(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset)
    1628 {
    1629     Assert((CODEC_CAD(cmd) == pState->id));
    1630     Assert((CODEC_NID(cmd) < pState->cTotalNodes));
    1631     if (CODEC_NID(cmd) >= pState->cTotalNodes)
    1632     {
    1633         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1653
     1654static int codecSetConfigX(PHDACODEC pState, uint32_t cmd, uint8_t u8Offset)
     1655{
     1656    Assert((CODEC_CAD(cmd) == pState->id));
     1657    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1658    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1659    {
     1660        Log(("HdaCodec: invalid node address %d\n", CODEC_NID(cmd)));
    16341661        return VINF_SUCCESS;
    16351662    }
    16361663    uint32_t *pu32Reg = NULL;
    1637     if (codecIsPortNode(pState, CODEC_NID(cmd)))
     1664    if (hdaCodecIsPortNode(pState, CODEC_NID(cmd)))
    16381665        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].port.u32F1c_param;
    1639     else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1666    else if (hdaCodecIsDigInPinNode(pState, CODEC_NID(cmd)))
    16401667        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digin.u32F1c_param;
    1641     else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1668    else if (hdaCodecIsDigOutPinNode(pState, CODEC_NID(cmd)))
    16421669        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].digout.u32F1c_param;
    1643     else if (codecIsCdNode(pState, CODEC_NID(cmd)))
     1670    else if (hdaCodecIsCdNode(pState, CODEC_NID(cmd)))
    16441671        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
    1645     else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1672    else if (hdaCodecIsPcbeepNode(pState, CODEC_NID(cmd)))
    16461673        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
    1647     else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1674    else if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
    16481675        pu32Reg = &pState->paNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
    16491676    Assert((pu32Reg));
    16501677    if (pu32Reg)
    1651         codecSetRegisterU8(pu32Reg, cmd, u8Offset);
    1652     return VINF_SUCCESS;
    1653 }
     1678        hdaCodecSetRegisterU8(pu32Reg, cmd, u8Offset);
     1679    return VINF_SUCCESS;
     1680}
     1681
    16541682/* 71C */
    1655 static int codecSetConfig0 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1683static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    16561684{
    16571685    *pResp = 0;
    16581686    return codecSetConfigX(pState, cmd, 0);
    16591687}
     1688
    16601689/* 71D */
    1661 static int codecSetConfig1 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1690static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    16621691{
    16631692    *pResp = 0;
    16641693    return codecSetConfigX(pState, cmd, 8);
    16651694}
     1695
    16661696/* 71E */
    1667 static int codecSetConfig2 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1697static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    16681698{
    16691699    *pResp = 0;
    16701700    return codecSetConfigX(pState, cmd, 16);
    16711701}
     1702
    16721703/* 71E */
    1673 static int codecSetConfig3 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1704static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pState, uint32_t cmd, uint64_t *pResp)
    16741705{
    16751706    *pResp = 0;
    … …  
    16781709
    16791710
    1680 static int codecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt)
     1711static int hdaCodecToAudVolume(AMPLIFIER *pAmp, audmixerctl_t mt)
    16811712{
    16821713    uint32_t dir = AMPLIFIER_OUT;
    … …  
    17011732}
    17021733
    1703 static CODECVERB CODECVERBS[] =
    1704 {
    1705 /*    verb     | verb mask              | callback               */
    1706 /*  -----------  --------------------   -----------------------  */
    1707     {0x000F0000, CODEC_VERB_8BIT_CMD , codecGetParameter           },
    1708     {0x000F0100, CODEC_VERB_8BIT_CMD , codecGetConSelectCtrl       },
    1709     {0x00070100, CODEC_VERB_8BIT_CMD , codecSetConSelectCtrl       },
    1710     {0x000F0600, CODEC_VERB_8BIT_CMD , codecGetStreamId            },
    1711     {0x00070600, CODEC_VERB_8BIT_CMD , codecSetStreamId            },
    1712     {0x000F0700, CODEC_VERB_8BIT_CMD , codecGetPinCtrl             },
    1713     {0x00070700, CODEC_VERB_8BIT_CMD , codecSetPinCtrl             },
    1714     {0x000F0800, CODEC_VERB_8BIT_CMD , codecGetUnsolicitedEnabled  },
    1715     {0x00070800, CODEC_VERB_8BIT_CMD , codecSetUnsolicitedEnabled  },
    1716     {0x000F0900, CODEC_VERB_8BIT_CMD , codecGetPinSense            },
    1717     {0x00070900, CODEC_VERB_8BIT_CMD , codecSetPinSense            },
    1718     {0x000F0200, CODEC_VERB_8BIT_CMD , codecGetConnectionListEntry },
    1719     {0x000F0300, CODEC_VERB_8BIT_CMD , codecGetProcessingState     },
    1720     {0x00070300, CODEC_VERB_8BIT_CMD , codecSetProcessingState     },
    1721     {0x000F0D00, CODEC_VERB_8BIT_CMD , codecGetDigitalConverter    },
    1722     {0x00070D00, CODEC_VERB_8BIT_CMD , codecSetDigitalConverter1   },
    1723     {0x00070E00, CODEC_VERB_8BIT_CMD , codecSetDigitalConverter2   },
    1724     {0x000F2000, CODEC_VERB_8BIT_CMD , codecGetSubId               },
    1725     {0x00072000, CODEC_VERB_8BIT_CMD , codecSetSubId0              },
    1726     {0x00072100, CODEC_VERB_8BIT_CMD , codecSetSubId1              },
    1727     {0x00072200, CODEC_VERB_8BIT_CMD , codecSetSubId2              },
    1728     {0x00072300, CODEC_VERB_8BIT_CMD , codecSetSubId3              },
    1729     {0x0007FF00, CODEC_VERB_8BIT_CMD , codecReset                  },
    1730     {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState          },
    1731     {0x00070500, CODEC_VERB_8BIT_CMD , codecSetPowerState          },
    1732     {0x000F0C00, CODEC_VERB_8BIT_CMD , codecGetEAPD_BTLEnabled     },
    1733     {0x00070C00, CODEC_VERB_8BIT_CMD , codecSetEAPD_BTLEnabled     },
    1734     {0x000F0F00, CODEC_VERB_8BIT_CMD , codecGetVolumeKnobCtrl      },
    1735     {0x00070F00, CODEC_VERB_8BIT_CMD , codecSetVolumeKnobCtrl      },
    1736     {0x000F1700, CODEC_VERB_8BIT_CMD , codecGetGPIOUnsolisted      },
    1737     {0x00071700, CODEC_VERB_8BIT_CMD , codecSetGPIOUnsolisted      },
    1738     {0x000F1C00, CODEC_VERB_8BIT_CMD , codecGetConfig              },
    1739     {0x00071C00, CODEC_VERB_8BIT_CMD , codecSetConfig0             },
    1740     {0x00071D00, CODEC_VERB_8BIT_CMD , codecSetConfig1             },
    1741     {0x00071E00, CODEC_VERB_8BIT_CMD , codecSetConfig2             },
    1742     {0x00071F00, CODEC_VERB_8BIT_CMD , codecSetConfig3             },
    1743     {0x000A0000, CODEC_VERB_16BIT_CMD, codecGetConverterFormat     },
    1744     {0x00020000, CODEC_VERB_16BIT_CMD, codecSetConverterFormat     },
    1745     {0x000B0000, CODEC_VERB_16BIT_CMD, codecGetAmplifier           },
    1746     {0x00030000, CODEC_VERB_16BIT_CMD, codecSetAmplifier           },
     1734/**
     1735 * HDA codec verb map.
     1736 * @todo Any reason not to use binary search here?
     1737 */
     1738static const CODECVERB g_aCodecVerbs[] =
     1739{
     1740/*     verb     | verb mask              | callback               */
     1741/*   -----------  --------------------   -----------------------  */
     1742    { 0x000F0000, CODEC_VERB_8BIT_CMD , vrbProcGetParameter           },
     1743    { 0x000F0100, CODEC_VERB_8BIT_CMD , vrbProcGetConSelectCtrl       },
     1744    { 0x00070100, CODEC_VERB_8BIT_CMD , vrbProcSetConSelectCtrl       },
     1745    { 0x000F0600, CODEC_VERB_8BIT_CMD , vrbProcGetStreamId            },
     1746    { 0x00070600, CODEC_VERB_8BIT_CMD , vrbProcSetStreamId            },
     1747    { 0x000F0700, CODEC_VERB_8BIT_CMD , vrbProcGetPinCtrl             },
     1748    { 0x00070700, CODEC_VERB_8BIT_CMD , vrbProcSetPinCtrl             },
     1749    { 0x000F0800, CODEC_VERB_8BIT_CMD , vrbProcGetUnsolicitedEnabled  },
     1750    { 0x00070800, CODEC_VERB_8BIT_CMD , vrbProcSetUnsolicitedEnabled  },
     1751    { 0x000F0900, CODEC_VERB_8BIT_CMD , vrbProcGetPinSense            },
     1752    { 0x00070900, CODEC_VERB_8BIT_CMD , vrbProcSetPinSense            },
     1753    { 0x000F0200, CODEC_VERB_8BIT_CMD , vrbProcGetConnectionListEntry },
     1754    { 0x000F0300, CODEC_VERB_8BIT_CMD , vrbProcGetProcessingState     },
     1755    { 0x00070300, CODEC_VERB_8BIT_CMD , vrbProcSetProcessingState     },
     1756    { 0x000F0D00, CODEC_VERB_8BIT_CMD , vrbProcGetDigitalConverter    },
     1757    { 0x00070D00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter1   },
     1758    { 0x00070E00, CODEC_VERB_8BIT_CMD , vrbProcSetDigitalConverter2   },
     1759    { 0x000F2000, CODEC_VERB_8BIT_CMD , vrbProcGetSubId               },
     1760    { 0x00072000, CODEC_VERB_8BIT_CMD , vrbProcSetSubId0              },
     1761    { 0x00072100, CODEC_VERB_8BIT_CMD , vrbProcSetSubId1              },
     1762    { 0x00072200, CODEC_VERB_8BIT_CMD , vrbProcSetSubId2              },
     1763    { 0x00072300, CODEC_VERB_8BIT_CMD , vrbProcSetSubId3              },
     1764    { 0x0007FF00, CODEC_VERB_8BIT_CMD , vrbProcReset                  },
     1765    { 0x000F0500, CODEC_VERB_8BIT_CMD , vrbProcGetPowerState          },
     1766    { 0x00070500, CODEC_VERB_8BIT_CMD , vrbProcSetPowerState          },
     1767    { 0x000F0C00, CODEC_VERB_8BIT_CMD , vrbProcGetEAPD_BTLEnabled     },
     1768    { 0x00070C00, CODEC_VERB_8BIT_CMD , vrbProcSetEAPD_BTLEnabled     },
     1769    { 0x000F0F00, CODEC_VERB_8BIT_CMD , vrbProcGetVolumeKnobCtrl      },
     1770    { 0x00070F00, CODEC_VERB_8BIT_CMD , vrbProcSetVolumeKnobCtrl      },
     1771    { 0x000F1700, CODEC_VERB_8BIT_CMD , vrbProcGetGPIOUnsolisted      },
     1772    { 0x00071700, CODEC_VERB_8BIT_CMD , vrbProcSetGPIOUnsolisted      },
     1773    { 0x000F1C00, CODEC_VERB_8BIT_CMD , vrbProcGetConfig              },
     1774    { 0x00071C00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig0             },
     1775    { 0x00071D00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig1             },
     1776    { 0x00071E00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig2             },
     1777    { 0x00071F00, CODEC_VERB_8BIT_CMD , vrbProcSetConfig3             },
     1778    { 0x000A0000, CODEC_VERB_16BIT_CMD, vrbProcGetConverterFormat     },
     1779    { 0x00020000, CODEC_VERB_16BIT_CMD, vrbProcSetConverterFormat     },
     1780    { 0x000B0000, CODEC_VERB_16BIT_CMD, vrbProcGetAmplifier           },
     1781    { 0x00030000, CODEC_VERB_16BIT_CMD, vrbProcSetAmplifier           },
    17471782};
    17481783
    1749 static int codecLookup(CODECState *pState, uint32_t cmd, PPFNCODECVERBPROCESSOR pfn)
     1784static int codecLookup(PHDACODEC pState, uint32_t cmd, PPFNCODECVERBPROCESSOR pfn)
    17501785{
    17511786    int rc = VINF_SUCCESS;
    17521787    Assert(CODEC_CAD(cmd) == pState->id);
    1753     if (codecIsReservedNode(pState, CODEC_NID(cmd)))
    1754     {
    1755         Log(("HDAcodec: cmd %x was addressed to reserved node\n", cmd));
    1756     }
     1788    if (hdaCodecIsReservedNode(pState, CODEC_NID(cmd)))
     1789        Log(("HdaCodec: cmd %x was addressed to reserved node\n", cmd));
     1790
    17571791    if (   CODEC_VERBDATA(cmd) == 0
    17581792        || CODEC_NID(cmd) >= pState->cTotalNodes)
    17591793    {
    1760         *pfn = codecUnimplemented;
    1761         //** @todo r=michaln: There needs to be a counter to avoid log flooding (see e.g. DevRTC.cpp)
    1762         Log(("HDAcodec: cmd %x was ignored\n", cmd));
    1763         return VINF_SUCCESS;
    1764     }
     1794        *pfn = vrbProcUnimplemented;
     1795        /// @todo r=michaln: There needs to be a counter to avoid log flooding (see e.g. DevRTC.cpp)
     1796        Log(("HdaCodec: cmd %x was ignored\n", cmd));
     1797        return VINF_SUCCESS;
     1798    }
     1799
    17651800    for (int i = 0; i < pState->cVerbs; ++i)
    17661801    {
    1767         if ((CODEC_VERBDATA(cmd) & pState->pVerbs[i].mask) == pState->pVerbs[i].verb)
     1802        if ((CODEC_VERBDATA(cmd) & pState->paVerbs[i].mask) == pState->paVerbs[i].verb)
    17681803        {
    1769             *pfn = pState->pVerbs[i].pfn;
     1804            *pfn = pState->paVerbs[i].pfn;
    17701805            return VINF_SUCCESS;
    17711806        }
    17721807    }
    1773     *pfn = codecUnimplemented;
    1774     Log(("HDAcodec: callback for %x wasn't found\n", CODEC_VERBDATA(cmd)));
     1808
     1809    *pfn = vrbProcUnimplemented;
     1810    Log(("HdaCodec: callback for %x wasn't found\n", CODEC_VERBDATA(cmd)));
    17751811    return rc;
    17761812}
    17771813
    1778 static void pi_callback (void *opaque, int avail)
    1779 {
    1780     CODECState *pState = (CODECState *)opaque;
     1814static void pi_callback(void *opaque, int avail)
     1815{
     1816    PHDACODEC pState = (PHDACODEC)opaque;
    17811817    pState->pfnTransfer(pState, PI_INDEX, avail);
    17821818}
    17831819
    1784 static void po_callback (void *opaque, int avail)
    1785 {
    1786     CODECState *pState = (CODECState *)opaque;
     1820static void po_callback(void *opaque, int avail)
     1821{
     1822    PHDACODEC pState = (PHDACODEC)opaque;
    17871823    pState->pfnTransfer(pState, PO_INDEX, avail);
    17881824}
     1825
     1826
     1827
     1828/*
     1829 * APIs exposed to DevHDA.
     1830 */
     1831
    17891832
    17901833/**
    … …  
    17931836 * this routine could be called from HDA on setting/resseting sound format.
    17941837 *
    1795  * @todo: probably passed settings should be verified (if AFG's declared proposed format) before enabling.
     1838 * @todo Probably passed settings should be verified (if AFG's declared proposed
     1839 *       format) before enabling.
    17961840 */
    1797 int codecOpenVoice(CODECState *pState, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings)
     1841int hdaCodecOpenVoice(PHDACODEC pState, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings)
    17981842{
    17991843    int rc = 0;
    … …  
    18161860    }
    18171861    if (!rc)
    1818         LogRel(("HDAcodec: can't open %s fmt(freq: %d)\n",
    1819             enmSoundSource == PI_INDEX? "in" : "out",
    1820             pAudioSettings->freq));
     1862        LogRel(("HdaCodec: can't open %s fmt(freq: %d)\n", enmSoundSource == PI_INDEX? "in" : "out", pAudioSettings->freq));
    18211863    return rc;
    18221864}
    18231865
    1824 int codecConstruct(PPDMDEVINS pDevIns, CODECState *pState, PCFGMNODE pCfgHandle)
    1825 {
    1826     audsettings_t as;
    1827     int rc;
    1828     pState->pVerbs = (CODECVERB *)&CODECVERBS;
    1829     pState->cVerbs = sizeof(CODECVERBS)/sizeof(CODECVERB);
    1830     pState->pfnLookup = codecLookup;
    1831     rc = stac9220Construct(pState);
    1832     AssertRC(rc);
    1833     /* common root node initializers */
    1834     pState->paNodes[0].node.au32F00_param[0] = CODEC_MAKE_F00_00(pState->u16VendorId, pState->u16DeviceId);
    1835     pState->paNodes[0].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
    1836     /* common AFG node initializers */
    1837     pState->paNodes[1].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x2, pState->cTotalNodes - 2);
    1838     pState->paNodes[1].node.au32F00_param[5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
    1839     pState->paNodes[1].afg.u32F20_param = CODEC_MAKE_F20(pState->u16VendorId, pState->u8BSKU, pState->u8AssemblyId);
    1840 
    1841     //** @todo r=michaln: Was this meant to be 'HDA' or something like that? (AC'97 was on ICH0)
    1842     AUD_register_card ("ICH0", &pState->card);
    1843 
    1844     /* 44.1 kHz */
    1845     as.freq = 44100;
    1846     as.nchannels = 2;
    1847     as.fmt = AUD_FMT_S16;
    1848     as.endianness = 0;
    1849 
    1850     pState->paNodes[1].node.au32F00_param[0xA] = CODEC_F00_0A_16_BIT;
    1851     codecOpenVoice(pState, PI_INDEX, &as);
    1852     codecOpenVoice(pState, PO_INDEX, &as);
    1853     pState->paNodes[1].node.au32F00_param[0xA] |= CODEC_F00_0A_44_1KHZ;
    1854 
    1855     uint8_t i;
    1856     Assert(pState->paNodes);
    1857     Assert(pState->pfnCodecNodeReset);
    1858     for (i = 0; i < pState->cTotalNodes; ++i)
    1859     {
    1860         pState->pfnCodecNodeReset(pState, i, &pState->paNodes[i]);
    1861     }
    1862 
    1863     codecToAudVolume(&pState->paNodes[pState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
    1864     codecToAudVolume(&pState->paNodes[pState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
    1865 
    1866     /* If no host voices were created, then fallback to nul audio. */
    1867     if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
    1868         LogRel (("HDA: WARNING: Unable to open PCM IN!\n"));
    1869     if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
    1870         LogRel (("HDA: WARNING: Unable to open PCM OUT!\n"));
    1871 
    1872     if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
    1873         && !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
    1874     {
    1875         /* Was not able initialize *any* voice. Select the NULL audio driver instead */
    1876         AUD_close_in  (&pState->card, pState->SwVoiceIn);
    1877         AUD_close_out (&pState->card, pState->SwVoiceOut);
    1878         pState->SwVoiceOut = NULL;
    1879         pState->SwVoiceIn = NULL;
    1880         AUD_init_null ();
    1881 
    1882         PDMDevHlpVMSetRuntimeError (pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
    1883             N_ ("No audio devices could be opened. Selecting the NULL audio backend "
    1884                 "with the consequence that no sound is audible"));
    1885     }
    1886     else if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
    1887              || !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
    1888     {
    1889         char   szMissingVoices[128];
    1890         size_t len = 0;
    1891         if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
    1892             len = RTStrPrintf (szMissingVoices, sizeof(szMissingVoices), "PCM_in");
    1893         if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
    1894             len += RTStrPrintf (szMissingVoices + len, sizeof(szMissingVoices) - len, len ? ", PCM_out" : "PCM_out");
    1895 
    1896         PDMDevHlpVMSetRuntimeError (pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
    1897             N_ ("Some audio devices (%s) could not be opened. Guest applications generating audio "
    1898                 "output or depending on audio input may hang. Make sure your host audio device "
    1899                 "is working properly. Check the logfile for error messages of the audio "
    1900                 "subsystem"), szMissingVoices);
    1901     }
    1902 
    1903     return VINF_SUCCESS;
    1904 }
    1905 
    1906 int codecDestruct(CODECState *pCodecState)
    1907 {
    1908     RTMemFree(pCodecState->paNodes);
    1909     pCodecState->paNodes = NULL;
    1910     return VINF_SUCCESS;
    1911 }
    1912 
    1913 int codecSaveState(CODECState *pCodecState, PSSMHANDLE pSSM)
     1866
     1867int hdaCodecSaveState(CODECState *pCodecState, PSSMHANDLE pSSM)
    19141868{
    19151869    AssertLogRelMsgReturn(pCodecState->cTotalNodes == 0x1c, ("cTotalNodes=%#x, should be 0x1c", pCodecState->cTotalNodes),
    … …  
    19231877
    19241878
    1925 int codecLoadState(CODECState *pCodecState, PSSMHANDLE pSSM, uint32_t uVersion)
     1879int hdaCodecLoadState(CODECState *pCodecState, PSSMHANDLE pSSM, uint32_t uVersion)
    19261880{
    19271881    PCSSMFIELD pFields;
    … …  
    19761930     * Update stuff after changing the state.
    19771931     */
    1978     if (codecIsDacNode(pCodecState, pCodecState->u8DacLineOut))
    1979         codecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
    1980     else if (codecIsSpdifOutNode(pCodecState, pCodecState->u8DacLineOut))
    1981         codecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].spdifout.B_params, AUD_MIXER_VOLUME);
    1982     codecToAudVolume(&pCodecState->paNodes[pCodecState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
    1983 
    1984     return VINF_SUCCESS;
    1985 }
    1986 
     1932    if (hdaCodecIsDacNode(pCodecState, pCodecState->u8DacLineOut))
     1933        hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
     1934    else if (hdaCodecIsSpdifOutNode(pCodecState, pCodecState->u8DacLineOut))
     1935        hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8DacLineOut].spdifout.B_params, AUD_MIXER_VOLUME);
     1936    hdaCodecToAudVolume(&pCodecState->paNodes[pCodecState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
     1937
     1938    return VINF_SUCCESS;
     1939}
     1940
     1941
     1942int hdaCodecDestruct(CODECState *pCodecState)
     1943{
     1944    RTMemFree(pCodecState->paNodes);
     1945    pCodecState->paNodes = NULL;
     1946    return VINF_SUCCESS;
     1947}
     1948
     1949
     1950int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pState, PCFGMNODE pCfg)
     1951{
     1952    pState->paVerbs   = &g_aCodecVerbs[0];
     1953    pState->cVerbs    = RT_ELEMENTS(g_aCodecVerbs);
     1954    pState->pfnLookup = codecLookup;
     1955    int rc = stac9220Construct(pState);
     1956    AssertRC(rc);
     1957
     1958    /* common root node initializers */
     1959    pState->paNodes[0].node.au32F00_param[0] = CODEC_MAKE_F00_00(pState->u16VendorId, pState->u16DeviceId);
     1960    pState->paNodes[0].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
     1961    /* common AFG node initializers */
     1962    pState->paNodes[1].node.au32F00_param[4] = CODEC_MAKE_F00_04(0x2, pState->cTotalNodes - 2);
     1963    pState->paNodes[1].node.au32F00_param[5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
     1964    pState->paNodes[1].afg.u32F20_param = CODEC_MAKE_F20(pState->u16VendorId, pState->u8BSKU, pState->u8AssemblyId);
     1965
     1966    //** @todo r=michaln: Was this meant to be 'HDA' or something like that? (AC'97 was on ICH0)
     1967    AUD_register_card ("ICH0", &pState->card);
     1968
     1969    /* 44.1 kHz */
     1970    audsettings_t as;
     1971    as.freq = 44100;
     1972    as.nchannels = 2;
     1973    as.fmt = AUD_FMT_S16;
     1974    as.endianness = 0;
     1975
     1976    pState->paNodes[1].node.au32F00_param[0xA] = CODEC_F00_0A_16_BIT;
     1977    hdaCodecOpenVoice(pState, PI_INDEX, &as);
     1978    hdaCodecOpenVoice(pState, PO_INDEX, &as);
     1979    pState->paNodes[1].node.au32F00_param[0xA] |= CODEC_F00_0A_44_1KHZ;
     1980
     1981    uint8_t i;
     1982    Assert(pState->paNodes);
     1983    Assert(pState->pfnCodecNodeReset);
     1984    for (i = 0; i < pState->cTotalNodes; ++i)
     1985    {
     1986        pState->pfnCodecNodeReset(pState, i, &pState->paNodes[i]);
     1987    }
     1988
     1989    hdaCodecToAudVolume(&pState->paNodes[pState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
     1990    hdaCodecToAudVolume(&pState->paNodes[pState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
     1991
     1992    /* If no host voices were created, then fallback to nul audio. */
     1993    if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
     1994        LogRel (("HDA: WARNING: Unable to open PCM IN!\n"));
     1995    if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
     1996        LogRel (("HDA: WARNING: Unable to open PCM OUT!\n"));
     1997
     1998    if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
     1999        && !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
     2000    {
     2001        /* Was not able initialize *any* voice. Select the NULL audio driver instead */
     2002        AUD_close_in  (&pState->card, pState->SwVoiceIn);
     2003        AUD_close_out (&pState->card, pState->SwVoiceOut);
     2004        pState->SwVoiceOut = NULL;
     2005        pState->SwVoiceIn = NULL;
     2006        AUD_init_null ();
     2007
     2008        PDMDevHlpVMSetRuntimeError (pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
     2009            N_ ("No audio devices could be opened. Selecting the NULL audio backend "
     2010                "with the consequence that no sound is audible"));
     2011    }
     2012    else if (   !AUD_is_host_voice_in_ok(pState->SwVoiceIn)
     2013             || !AUD_is_host_voice_out_ok(pState->SwVoiceOut))
     2014    {
     2015        char   szMissingVoices[128];
     2016        size_t len = 0;
     2017        if (!AUD_is_host_voice_in_ok(pState->SwVoiceIn))
     2018            len = RTStrPrintf (szMissingVoices, sizeof(szMissingVoices), "PCM_in");
     2019        if (!AUD_is_host_voice_out_ok(pState->SwVoiceOut))
     2020            len += RTStrPrintf (szMissingVoices + len, sizeof(szMissingVoices) - len, len ? ", PCM_out" : "PCM_out");
     2021
     2022        PDMDevHlpVMSetRuntimeError (pDevIns, 0 /*fFlags*/, "HostAudioNotResponding",
     2023            N_ ("Some audio devices (%s) could not be opened. Guest applications generating audio "
     2024                "output or depending on audio input may hang. Make sure your host audio device "
     2025                "is working properly. Check the logfile for error messages of the audio "
     2026                "subsystem"), szMissingVoices);
     2027    }
     2028
     2029    return VINF_SUCCESS;
     2030}
     2031

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

    r44639 r44667  
    1818#ifndef DEV_CODEC_H
    1919#define DEV_CODEC_H
     20
    2021struct CODECState;
    21 struct INTELHDLinkState;
    22 
    23 typedef DECLCALLBACK(int) FNCODECVERBPROCESSOR(struct CODECState *pState, uint32_t cmd, uint64_t *pResp);
     22
     23typedef DECLCALLBACK(int) FNCODECVERBPROCESSOR(struct CODECState *pThis, uint32_t cmd, uint64_t *pResp);
    2424typedef FNCODECVERBPROCESSOR *PFNCODECVERBPROCESSOR;
    2525typedef FNCODECVERBPROCESSOR **PPFNCODECVERBPROCESSOR;
    2626
    27 /* RPM 5.3.1 */
     27/* PRM 5.3.1 */
    2828#define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
    2929
    … …  
    483483    uint8_t                 u8AssemblyId;
    484484#ifndef VBOX_WITH_HDA_CODEC_EMU
    485     CODECVERB               *pVerbs;
     485    CODECVERB const        *paVerbs;
    486486    int                     cVerbs;
    487487#else
    … …  
    521521    DECLR3CALLBACKMEMBER(int, pfnCodecNodeReset, (struct CODECState *pState, uint8_t, PCODECNODE));
    522522    /* These callbacks are set by codec implementation to answer debugger requests */
    523     DECLR3CALLBACKMEMBER(void, pfnCodecDbgListNodes, (CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
    524     DECLR3CALLBACKMEMBER(void, pfnCodecDbgSelector, (CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
     523    DECLR3CALLBACKMEMBER(void, pfnCodecDbgListNodes, (struct CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
     524    DECLR3CALLBACKMEMBER(void, pfnCodecDbgSelector, (struct CODECState *pState, PCDBGFINFOHLP pHlp, const char *pszArgs));
    525525} CODECState, *PCODECState;
    526526/** The ICH HDA (Intel) codec state. */
    … …  
    529529typedef HDACODEC *PHDACODEC;
    530530
    531 int codecConstruct(PPDMDEVINS pDevIns, CODECState *pCodecState, PCFGMNODE pCfgHandle);
    532 int codecDestruct(CODECState *pCodecState);
    533 int codecSaveState(CODECState *pCodecState, PSSMHANDLE pSSMHandle);
    534 int codecLoadState(CODECState *pCodecState, PSSMHANDLE pSSMHandle, uint32_t uVersion);
    535 int codecOpenVoice(CODECState *pCodecState, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings);
     531int hdaCodecConstruct(PPDMDEVINS pDevIns, PHDACODEC pThis, PCFGMNODE pCfg);
     532int hdaCodecDestruct(PHDACODEC pThis);
     533int hdaCodecSaveState(PHDACODEC pThis, PSSMHANDLE pSSM);
     534int hdaCodecLoadState(PHDACODEC pThis, PSSMHANDLE pSSM, uint32_t uVersion);
     535int hdaCodecOpenVoice(PHDACODEC pThis, ENMSOUNDSOURCE enmSoundSource, audsettings_t *pAudioSettings);
    536536
    537537#define HDA_SSM_VERSION   4
    … …  
    544544struct CODECEMU
    545545{
    546     DECLR3CALLBACKMEMBER(int, pfnCodecEmuConstruct, (PCODECState pState));
    547     DECLR3CALLBACKMEMBER(int, pfnCodecEmuDestruct, (PCODECState pState));
    548     DECLR3CALLBACKMEMBER(int, pfnCodecEmuReset, (PCODECState pState, bool fInit));
     546    DECLR3CALLBACKMEMBER(int, pfnCodecEmuConstruct,(PHDACODEC pThis));
     547    DECLR3CALLBACKMEMBER(int, pfnCodecEmuDestruct,(PHDACODEC pThis));
     548    DECLR3CALLBACKMEMBER(int, pfnCodecEmuReset,(PHDACODEC pThis, bool fInit));
    549549};
    550550# endif

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

    r44666 r44667  
    14791479    {
    14801480        case ICH6_HDA_REG_SD0FMT:
    1481             rc = codecOpenVoice(&pThis->Codec, PI_INDEX, &as);
     1481            rc = hdaCodecOpenVoice(&pThis->Codec, PI_INDEX, &as);
    14821482            break;
    14831483        case ICH6_HDA_REG_SD4FMT:
    1484             rc = codecOpenVoice(&pThis->Codec, PO_INDEX, &as);
     1484            rc = hdaCodecOpenVoice(&pThis->Codec, PO_INDEX, &as);
    14851485            break;
    14861486        default:
    … …  
    23962396    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
    23972397    /* Save Codec nodes states */
    2398     codecSaveState(&pThis->Codec, pSSM);
     2398    hdaCodecSaveState(&pThis->Codec, pSSM);
    23992399
    24002400    /* Save MMIO registers */
    … …  
    24232423     * Load Codec nodes states.
    24242424     */
    2425     int rc = codecLoadState(&pThis->Codec, pSSM, uVersion);
     2425    int rc = hdaCodecLoadState(&pThis->Codec, pSSM, uVersion);
    24262426    if (RT_FAILURE(rc))
    24272427        return rc;
    … …  
    27752775    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
    27762776
    2777     int rc = codecDestruct(&pThis->Codec);
     2777    int rc = hdaCodecDestruct(&pThis->Codec);
    27782778    AssertRC(rc);
    27792779
    … …  
    29342934
    29352935    pThis->Codec.pvHDAState = pThis;
    2936     rc = codecConstruct(pDevIns, &pThis->Codec, pCfgHandle);
     2936    rc = hdaCodecConstruct(pDevIns, &pThis->Codec, pCfgHandle);
    29372937    if (RT_FAILURE(rc))
    29382938        AssertRCReturn(rc, rc);
Note: See TracChangeset for help on using the changeset viewer.

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