VirtualBox

Changeset 90147 in vbox for trunk


Ignore:
Timestamp:
Jul 10, 2021 12:36:44 AM (4 years ago)
Author:
vboxsync
Message:

DevHdaCodec: Moved the codec configuration into a separate structure so we can just have it as a const member in HDACODECR3, both making it simpler to unconst during construction and making clearer what's configuration and what's state. Changed HDACODECR3::fInReset into a stac9220NodeReset parameter. bugref:9890

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

Legend:

Unmodified
Added
Removed

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

    r90142 r90147  
    49914991    /* ICH6 datasheet defines 0 values for SVID and SID (18.1.14-15), which together with values returned for
    49924992       verb F20 should provide device/codec recognition. */
    4993     Assert(pThisCC->Codec.idVendor);
    4994     Assert(pThisCC->Codec.idDevice);
    4995     PDMPciDevSetSubSystemVendorId(pPciDev, pThisCC->Codec.idVendor); /* 2c ro - intel.) */
    4996     PDMPciDevSetSubSystemId(      pPciDev, pThisCC->Codec.idDevice); /* 2e ro. */
     4993    Assert(pThisCC->Codec.Cfg.idVendor);
     4994    Assert(pThisCC->Codec.Cfg.idDevice);
     4995    PDMPciDevSetSubSystemVendorId(pPciDev, pThisCC->Codec.Cfg.idVendor); /* 2c ro - intel.) */
     4996    PDMPciDevSetSubSystemId(      pPciDev, pThisCC->Codec.Cfg.idDevice); /* 2e ro. */
    49974997
    49984998    /*

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

    r90145 r90147  
    189189 * Resets a single node of the codec.
    190190 *
    191  * @param   pThis               HDA codec of node to reset.
    192  * @param   uNID                Node ID to set node to.
    193  * @param   pNode               Node to reset.
    194  */
    195 static void stac9220NodeReset(PHDACODECR3 pThis, uint8_t uNID, PCODECNODE pNode)
     191 * @param   pThis       HDA codec of node to reset.
     192 * @param   uNID        Node ID to set node to.
     193 * @param   pNode       Node to reset.
     194 * @param   fInReset    Set if we're called from hdaCodecReset via
     195 *                      stac9220Reset, clear if called from stac9220Construct.
     196 */
     197static void stac9220NodeReset(PHDACODECR3 pThis, uint8_t uNID, PCODECNODE pNode, bool const fInReset)
    196198{
    197199    LogFlowFunc(("NID=0x%x (%RU8)\n", uNID, uNID));
    198200
    199     if (   !pThis->fInReset
     201    if (   !fInReset
    200202        && (   uNID != STAC9220_NID_ROOT
    201203            && uNID != STAC9220_NID_AFG)
    … …  
    391393            pNode->port.node.au32F02_param[0]   = STAC9220_NID_DAC0;
    392394
    393             if (!pThis->fInReset)
     395            if (!fInReset)
    394396                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    395397                                                          CODEC_F1C_LOCATION_FRONT,
    … …  
    415417            pNode->port.node.au32F02_param[0]   = STAC9220_NID_DAC2;
    416418
    417             if (!pThis->fInReset)
     419            if (!fInReset)
    418420                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    419421                                                          CODEC_F1C_LOCATION_REAR,
    … …  
    439441            pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC1;
    440442
    441             if (!pThis->fInReset)
     443            if (!fInReset)
    442444                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    443445                                                          CODEC_F1C_LOCATION_REAR,
    … …  
    464466            pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC0;
    465467
    466             if (!pThis->fInReset)
     468            if (!fInReset)
    467469                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    468470                                                          CODEC_F1C_LOCATION_FRONT,
    … …  
    505507                                                | CODEC_F00_0C_CAP_PRESENCE_DETECT;
    506508
    507             if (!pThis->fInReset)
     509            if (!fInReset)
    508510                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    509511                                                          CODEC_F1C_LOCATION_REAR,
    … …  
    535537            pNode->port.node.au32F02_param[0x0] = STAC9220_NID_DAC3;
    536538
    537             if (!pThis->fInReset)
     539            if (!fInReset)
    538540                pNode->port.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    539541                                                          CODEC_F1C_LOCATION_INTERNAL,
    … …  
    561563            pNode->digout.node.au32F02_param[0x0] = RT_MAKE_U32_FROM_U8(STAC9220_NID_SPDIF_OUT,
    562564                                                                        STAC9220_NID_AMP_ADC0, STAC9221_NID_ADAT_OUT, 0);
    563             if (!pThis->fInReset)
     565            if (!fInReset)
    564566                pNode->digout.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    565567                                                            CODEC_F1C_LOCATION_REAR,
    … …  
    589591                                                 | CODEC_F00_0C_CAP_INPUT
    590592                                                 | CODEC_F00_0C_CAP_PRESENCE_DETECT;
    591             if (!pThis->fInReset)
     593            if (!fInReset)
    592594                pNode->digin.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_COMPLEX,
    593595                                                           CODEC_F1C_LOCATION_REAR,
    … …  
    656658            pNode->cdnode.node.au32F00_param[0xC] = CODEC_F00_0C_CAP_INPUT;
    657659
    658             if (!pThis->fInReset)
     660            if (!fInReset)
    659661                pNode->cdnode.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_FIXED,
    660662                                                            CODEC_F1C_LOCATION_INTERNAL,
    … …  
    745747            pNode->node.au32F02_param[0]   = STAC9221_NID_I2S_OUT;
    746748
    747             if (!pThis->fInReset)
     749            if (!fInReset)
    748750                pNode->reserved.u32F1c_param = CODEC_MAKE_F1C(CODEC_F1C_PORT_NO_PHYS,
    749751                                                              CODEC_F1C_LOCATION_NA,
    … …  
    774776    LogRel(("HDA: Codec reset\n"));
    775777
    776     pThis->fInReset = true;
    777 
    778     uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     778    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    779779    for (uint8_t i = 0; i < cTotalNodes; i++)
    780         stac9220NodeReset(pThis, i, &pThis->aNodes[i]);
    781 
    782     pThis->fInReset = false;
    783 }
    784 
    785 
    786 static int stac9220Construct(PHDACODECR3 pThis)
    787 {
    788     pThis->idVendor     = 0x8384; /* SigmaTel */
     780        stac9220NodeReset(pThis, i, &pThis->aNodes[i], true /*fInReset*/);
     781}
     782
     783
     784static int stac9220Construct(PHDACODECR3 pThis, HDACODECCFG *pCfg)
     785{
    789786    /*
    790787     * Note: The Linux kernel uses "patch_stac922x" for the fixups,
    … …  
    792789     *       defaults tweaking in sound/pci/hda/patch_sigmatel.c.
    793790     */
    794     pThis->idDevice     = 0x7680; /* STAC9221 A1 */
    795     pThis->bBSKU        = 0x76;
    796     pThis->idAssembly   = 0x80;
    797 
    798     pThis->fInReset = false;
    799 
    800     uint16_t *pafNodeClassifications = (uint16_t *)&pThis->afNodeClassifications[0];
     791    pCfg->idVendor          = 0x8384; /* SigmaTel */
     792    pCfg->idDevice          = 0x7680; /* STAC9221 A1 */
     793    pCfg->bBSKU             = 0x76;
     794    pCfg->idAssembly        = 0x80;
     795
     796    AssertCompile(STAC9221_NUM_NODES <= RT_ELEMENTS(pThis->aNodes));
     797    pCfg->cTotalNodes       = STAC9221_NUM_NODES;
     798    pCfg->u8AdcVolsLineIn   = STAC9220_NID_AMP_ADC0;
     799    pCfg->u8DacLineOut      = STAC9220_NID_DAC1;
     800
     801    /* Copy over the node class lists and popuplate afNodeClassifications. */
    801802#define STAC9220WIDGET(a_Type) do { \
    802             AssertCompile(RT_ELEMENTS(g_abStac9220##a_Type##s) <= RT_ELEMENTS(pThis->ab##a_Type##s)); \
    803             uint8_t  *pbDst = (uint8_t *)&pThis->ab##a_Type##s[0]; \
     803            AssertCompile(RT_ELEMENTS(g_abStac9220##a_Type##s) <= RT_ELEMENTS(pCfg->ab##a_Type##s)); \
     804            uint8_t  *pbDst = (uint8_t *)&pCfg->ab##a_Type##s[0]; \
    804805            uintptr_t i; \
    805806            for (i = 0; i < RT_ELEMENTS(g_abStac9220##a_Type##s); i++) \
    806807            { \
    807808                uint8_t const idNode = g_abStac9220##a_Type##s[i]; \
    808                 if (idNode != 0) \
    809                 { \
    810                     AssertReturn(idNode < RT_ELEMENTS(pThis->aNodes), VERR_INTERNAL_ERROR_3); \
    811                     pafNodeClassifications[idNode] |= RT_CONCAT(CODEC_NODE_CLS_,a_Type); \
    812                 } \
     809                if (idNode == 0) \
     810                    break; \
     811                AssertReturn(idNode < RT_ELEMENTS(pThis->aNodes), VERR_INTERNAL_ERROR_3); \
     812                pCfg->afNodeClassifications[idNode] |= RT_CONCAT(CODEC_NODE_CLS_,a_Type); \
    813813                pbDst[i] = idNode; \
    814814            } \
    815             for (; i < RT_ELEMENTS(pThis->ab##a_Type##s); i++) \
     815            Assert(i + 1 == RT_ELEMENTS(g_abStac9220##a_Type##s)); \
     816            for (; i < RT_ELEMENTS(pCfg->ab##a_Type##s); i++) \
    816817                pbDst[i] = 0; \
    817818        } while (0)
    … …  
    831832#undef STAC9220WIDGET
    832833
    833     AssertCompile(STAC9221_NUM_NODES <= RT_ELEMENTS(pThis->aNodes));
    834     pThis->cTotalNodes = STAC9221_NUM_NODES;
    835 
    836     pThis->u8AdcVolsLineIn = STAC9220_NID_AMP_ADC0;
    837     pThis->u8DacLineOut    = STAC9220_NID_DAC1;
    838 
    839834    /*
    840835     * Initialize all codec nodes.
    … …  
    845840     */
    846841    for (uint8_t i = 0; i < STAC9221_NUM_NODES; i++)
    847         stac9220NodeReset(pThis, i, &pThis->aNodes[i]);
     842        stac9220NodeReset(pThis, i, &pThis->aNodes[i], false /*fInReset*/);
    848843
    849844    /* Common root node initializers. */
    850     pThis->aNodes[STAC9220_NID_ROOT].root.node.au32F00_param[0] = CODEC_MAKE_F00_00(pThis->idVendor, pThis->idDevice);
     845    pThis->aNodes[STAC9220_NID_ROOT].root.node.au32F00_param[0] = CODEC_MAKE_F00_00(pCfg->idVendor, pCfg->idDevice);
    851846    pThis->aNodes[STAC9220_NID_ROOT].root.node.au32F00_param[4] = CODEC_MAKE_F00_04(0x1, 0x1);
    852847
    … …  
    855850    pThis->aNodes[STAC9220_NID_AFG].afg.node.au32F00_param[0x5] = CODEC_MAKE_F00_05(1, CODEC_F00_05_AFG);
    856851    pThis->aNodes[STAC9220_NID_AFG].afg.node.au32F00_param[0xA] = CODEC_F00_0A_44_1KHZ | CODEC_F00_0A_16_BIT;
    857     pThis->aNodes[STAC9220_NID_AFG].afg.u32F20_param = CODEC_MAKE_F20(pThis->idVendor, pThis->bBSKU, pThis->idAssembly);
     852    pThis->aNodes[STAC9220_NID_AFG].afg.u32F20_param = CODEC_MAKE_F20(pCfg->idVendor, pCfg->bBSKU, pCfg->idAssembly);
    858853
    859854    return VINF_SUCCESS;
    … …  
    871866    DECLINLINE(bool) hdaCodecIs##a_Type##Node(PHDACODECR3 pThis, uint8_t idNode) \
    872867    { \
    873         Assert(idNode < RT_ELEMENTS(pThis->afNodeClassifications)); \
    874         Assert(   (memchr(&pThis->RT_CONCAT3(ab,a_Type,s)[0], idNode, sizeof(pThis->RT_CONCAT3(ab,a_Type,s))) != NULL) \
    875                == RT_BOOL(pThis->afNodeClassifications[idNode] & RT_CONCAT(CODEC_NODE_CLS_,a_Type))); \
    876         return RT_BOOL(pThis->afNodeClassifications[idNode] & RT_CONCAT(CODEC_NODE_CLS_,a_Type)); \
     868        Assert(idNode < RT_ELEMENTS(pThis->Cfg.afNodeClassifications)); \
     869        Assert(   (memchr(&pThis->Cfg.RT_CONCAT3(ab,a_Type,s)[0], idNode, sizeof(pThis->Cfg.RT_CONCAT3(ab,a_Type,s))) != NULL) \
     870               == RT_BOOL(pThis->Cfg.afNodeClassifications[idNode] & RT_CONCAT(CODEC_NODE_CLS_,a_Type))); \
     871        return RT_BOOL(pThis->Cfg.afNodeClassifications[idNode] & RT_CONCAT(CODEC_NODE_CLS_,a_Type)); \
    877872    }
    878873/* hdaCodecIsPortNode */
    … …  
    13761371static DECLCALLBACK(int) vrbProcGetSubId(PHDACODECR3 pThis, uint32_t uCmd, uint64_t *puResp)
    13771372{
    1378     Assert(CODEC_CAD(uCmd) == pThis->id);
    1379     uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     1373    Assert(CODEC_CAD(uCmd) == pThis->Cfg.id);
     1374    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    13801375    Assert(CODEC_NID(uCmd) < cTotalNodes);
    13811376    if (CODEC_NID(uCmd) >= cTotalNodes)
    … …  
    13951390static int codecSetSubIdX(PHDACODECR3 pThis, uint32_t uCmd, uint8_t u8Offset)
    13961391{
    1397     Assert(CODEC_CAD(uCmd) == pThis->id);
    1398     uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     1392    Assert(CODEC_CAD(uCmd) == pThis->Cfg.id);
     1393    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    13991394    Assert(CODEC_NID(uCmd) < cTotalNodes);
    14001395    if (CODEC_NID(uCmd) >= cTotalNodes)
    … …  
    14581453static DECLCALLBACK(int) vrbProcReset(PHDACODECR3 pThis, uint32_t uCmd, uint64_t *puResp)
    14591454{
    1460     Assert(CODEC_CAD(uCmd) == pThis->id);
    1461 
    1462     if (pThis->enmType == CODECTYPE_STAC9220)
     1455    Assert(CODEC_CAD(uCmd) == pThis->Cfg.id);
     1456
     1457    if (pThis->Cfg.enmType == CODECTYPE_STAC9220)
    14631458    {
    14641459        Assert(CODEC_NID(uCmd) == STAC9220_NID_AFG);
    … …  
    15801575        } while (0)
    15811576
    1582         PROPAGATE_PWR_STATE(pThis->abDacs,       dac);
    1583         PROPAGATE_PWR_STATE(pThis->abAdcs,       adc);
    1584         PROPAGATE_PWR_STATE(pThis->abDigInPins,  digin);
    1585         PROPAGATE_PWR_STATE(pThis->abDigOutPins, digout);
    1586         PROPAGATE_PWR_STATE(pThis->abSpdifIns,   spdifin);
    1587         PROPAGATE_PWR_STATE(pThis->abSpdifOuts,  spdifout);
    1588         PROPAGATE_PWR_STATE(pThis->abReserveds,  reserved);
     1577        PROPAGATE_PWR_STATE(pThis->Cfg.abDacs,       dac);
     1578        PROPAGATE_PWR_STATE(pThis->Cfg.abAdcs,       adc);
     1579        PROPAGATE_PWR_STATE(pThis->Cfg.abDigInPins,  digin);
     1580        PROPAGATE_PWR_STATE(pThis->Cfg.abDigOutPins, digout);
     1581        PROPAGATE_PWR_STATE(pThis->Cfg.abSpdifIns,   spdifin);
     1582        PROPAGATE_PWR_STATE(pThis->Cfg.abSpdifOuts,  spdifout);
     1583        PROPAGATE_PWR_STATE(pThis->Cfg.abReserveds,  reserved);
    15891584
    15901585#undef PROPAGATE_PWR_STATE
    … …  
    16251620static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODECR3 pThis, uint32_t uCmd, uint64_t *puResp)
    16261621{
    1627     Assert(CODEC_CAD(uCmd) == pThis->id);
    1628     uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     1622    Assert(CODEC_CAD(uCmd) == pThis->Cfg.id);
     1623    uint8_t const cTotalNodes = (uint8_t)RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    16291624    Assert(CODEC_NID(uCmd) < cTotalNodes);
    16301625    if (CODEC_NID(uCmd) >= cTotalNodes)
    … …  
    21012096            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
    21022097
    2103     //    if (CODEC_NID(uCmd) == pThis->u8AdcVolsLineIn)
     2098    //    if (CODEC_NID(uCmd) == pThis->Cfg.u8AdcVolsLineIn)
    21042099    //    {
    21052100            hdaR3CodecToAudVolume(pThis, pNode, pAmplifier, PDMAUDIOMIXERCTL_LINE_IN);
    … …  
    21132108            hdaCodecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), uCmd, 0);
    21142109
    2115         if (CODEC_NID(uCmd) == pThis->u8DacLineOut)
     2110        if (CODEC_NID(uCmd) == pThis->Cfg.u8DacLineOut)
    21162111            hdaR3CodecToAudVolume(pThis, pNode, pAmplifier, PDMAUDIOMIXERCTL_FRONT);
    21172112    }
    … …  
    22692264    *puResp = 0;
    22702265    AssertPtr(pThis);
    2271     AssertMsgReturn(CODEC_CAD(uCmd) == pThis->id,
     2266    AssertMsgReturn(CODEC_CAD(uCmd) == pThis->Cfg.id,
    22722267                    ("Unknown codec address 0x%x\n", CODEC_CAD(uCmd)),
    22732268                    VERR_INVALID_PARAMETER);
    22742269    uint32_t const uCmdData = CODEC_VERBDATA(uCmd);
    22752270    AssertMsgReturn(   uCmdData != 0
    2276                     && CODEC_NID(uCmd) < RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes)),
     2271                    && CODEC_NID(uCmd) < RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes)),
    22772272                    ("[NID0x%02x] Unknown / invalid node or data (0x%x)\n", CODEC_NID(uCmd), uCmdData),
    22782273                    VERR_INVALID_PARAMETER);
    … …  
    25212516
    25222517        /* Slow recursion, but this is debug stuff anyway. */
    2523         for (uint8_t i = 0; i < pInfo->pThis->cTotalNodes; i++)
     2518        for (uint8_t i = 0; i < pInfo->pThis->Cfg.cTotalNodes; i++)
    25242519        {
    25252520            const PCODECNODE pSubNode = &pInfo->pThis->aNodes[i];
    … …  
    25612556
    25622557    CODECDBG_INDENT
    2563         for (uint8_t i = 0; i < pThis->cTotalNodes; i++)
     2558        for (uint8_t i = 0; i < pThis->Cfg.cTotalNodes; i++)
    25642559        {
    25652560            PCODECNODE pNode = &pThis->aNodes[i];
    … …  
    25862581{
    25872582    RT_NOREF(pszArgs);
    2588     uint8_t const cTotalNodes = RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     2583    uint8_t const cTotalNodes = RT_MIN(pThis->Cfg.cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    25892584    for (uint8_t i = 1; i < cTotalNodes; i++)
    25902585    {
    … …  
    26642659{
    26652660    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
    2666     AssertLogRelMsgReturn(pThis->cTotalNodes == STAC9221_NUM_NODES, ("cTotalNodes=%#x, should be 0x1c", pThis->cTotalNodes),
     2661    AssertLogRelMsgReturn(pThis->Cfg.cTotalNodes == STAC9221_NUM_NODES, ("cTotalNodes=%#x, should be 0x1c", pThis->Cfg.cTotalNodes),
    26672662                          VERR_INTERNAL_ERROR);
    2668     pHlp->pfnSSMPutU32(pSSM, pThis->cTotalNodes);
    2669     for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
     2663    pHlp->pfnSSMPutU32(pSSM, pThis->Cfg.cTotalNodes);
     2664    for (unsigned idxNode = 0; idxNode < pThis->Cfg.cTotalNodes; ++idxNode)
    26702665        pHlp->pfnSSMPutStructEx(pSSM, &pThis->aNodes[idxNode].SavedState, sizeof(pThis->aNodes[idxNode].SavedState),
    26712666                                0 /*fFlags*/, g_aCodecNodeFields, NULL /*pvUser*/);
    … …  
    26952690        AssertRCReturn(rc2, rc2);
    26962691        AssertReturn(cNodes == 0x1c, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    2697         AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
     2692        AssertReturn(pThis->Cfg.cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
    26982693
    26992694        pFields = g_aCodecNodeFields;
    … …  
    27022697    else if (uVersion >= HDA_SAVED_STATE_VERSION_2)
    27032698    {
    2704         AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
     2699        AssertReturn(pThis->Cfg.cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
    27052700        pFields = g_aCodecNodeFields;
    27062701        fFlags  = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
    … …  
    27082703    else if (uVersion >= HDA_SAVED_STATE_VERSION_1)
    27092704    {
    2710         AssertReturn(pThis->cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
     2705        AssertReturn(pThis->Cfg.cTotalNodes == 0x1c, VERR_INTERNAL_ERROR);
    27112706        pFields = g_aCodecNodeFieldsV1;
    27122707        fFlags  = SSMSTRUCT_FLAGS_MEM_BAND_AID_RELAXED;
    … …  
    27152710        AssertFailedReturn(VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
    27162711
    2717     for (unsigned idxNode = 0; idxNode < pThis->cTotalNodes; ++idxNode)
     2712    for (unsigned idxNode = 0; idxNode < pThis->Cfg.cTotalNodes; ++idxNode)
    27182713    {
    27192714        uint8_t idOld = pThis->aNodes[idxNode].SavedState.Core.uID;
    … …  
    27302725     */
    27312726    PCODECNODE pNode;
    2732     if (hdaCodecIsDacNode(pThis, pThis->u8DacLineOut))
    2733     {
    2734         pNode = &pThis->aNodes[pThis->u8DacLineOut];
     2727    if (hdaCodecIsDacNode(pThis, pThis->Cfg.u8DacLineOut))
     2728    {
     2729        pNode = &pThis->aNodes[pThis->Cfg.u8DacLineOut];
    27352730        hdaR3CodecToAudVolume(pThis, pNode, &pNode->dac.B_params, PDMAUDIOMIXERCTL_FRONT);
    27362731    }
    2737     else if (hdaCodecIsSpdifOutNode(pThis, pThis->u8DacLineOut))
    2738     {
    2739         pNode = &pThis->aNodes[pThis->u8DacLineOut];
     2732    else if (hdaCodecIsSpdifOutNode(pThis, pThis->Cfg.u8DacLineOut))
     2733    {
     2734        pNode = &pThis->aNodes[pThis->Cfg.u8DacLineOut];
    27402735        hdaR3CodecToAudVolume(pThis, pNode, &pNode->spdifout.B_params, PDMAUDIOMIXERCTL_FRONT);
    27412736    }
    27422737
    2743     pNode = &pThis->aNodes[pThis->u8AdcVolsLineIn];
     2738    pNode = &pThis->aNodes[pThis->Cfg.u8AdcVolsLineIn];
    27442739    hdaR3CodecToAudVolume(pThis, pNode, &pNode->adcvol.B_params, PDMAUDIOMIXERCTL_LINE_IN);
    27452740
    … …  
    27912786    AssertPtrReturn(pThis,   VERR_INVALID_POINTER);
    27922787    AssertPtrReturn(pCfg,    VERR_INVALID_POINTER);
    2793 
    2794     pThis->id      = uLUN;
    2795     pThis->enmType = CODECTYPE_STAC9220; /** @todo Make this dynamic. */
     2788    HDACODECCFG *pCodecCfg = (HDACODECCFG *)&pThis->Cfg;
     2789
     2790    pCodecCfg->id      = uLUN;
     2791    pCodecCfg->enmType = CODECTYPE_STAC9220; /** @todo Make this dynamic. */
    27962792
    27972793    int rc;
    27982794
    2799     switch (pThis->enmType)
     2795    switch (pCodecCfg->enmType)
    28002796    {
    28012797        case CODECTYPE_STAC9220:
    28022798        {
    2803             rc = stac9220Construct(pThis);
     2799            rc = stac9220Construct(pThis, pCodecCfg);
    28042800            AssertRCReturn(rc, rc);
    28052801            break;
    … …  
    28142810     * Set initial volume.
    28152811     */
    2816     PCODECNODE pNode = &pThis->aNodes[pThis->u8DacLineOut];
     2812    PCODECNODE pNode = &pThis->aNodes[pCodecCfg->u8DacLineOut];
    28172813    rc = hdaR3CodecToAudVolume(pThis, pNode, &pNode->dac.B_params, PDMAUDIOMIXERCTL_FRONT);
    28182814    AssertRCReturn(rc, rc);
    28192815
    2820     pNode = &pThis->aNodes[pThis->u8AdcVolsLineIn];
     2816    pNode = &pThis->aNodes[pCodecCfg->u8AdcVolsLineIn];
    28212817    rc = hdaR3CodecToAudVolume(pThis, pNode, &pNode->adcvol.B_params, PDMAUDIOMIXERCTL_LINE_IN);
    28222818    AssertRCReturn(rc, rc);
    … …  
    28592855void hdaCodecReset(PHDACODECR3 pThis)
    28602856{
    2861     switch (pThis->enmType)
     2857    switch (pThis->Cfg.enmType)
    28622858    {
    28632859        case CODECTYPE_STAC9220:

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

    r90146 r90147  
    807807/** @} */
    808808
    809 
    810809/**
    811  * HDA codec state (ring-3, no shared state).
     810 * Code configuration.
     811 *
     812 * This will not change after construction and is therefore kept in a const
     813 * member of HDACODECR3 to encourage compiler optimizations and avoid accidental
     814 * modification.
    812815 */
    813 typedef struct HDACODECR3
     816typedef struct HDACODECCFG
    814817{
    815818    /** Codec implementation type. */
    … …  
    822825    uint8_t         idAssembly;
    823826
    824     bool            fInReset;
    825 
    826827    uint8_t         cTotalNodes;
    827828    uint8_t         u8AdcVolsLineIn;
    … …  
    830831    /** Align the lists below so they don't cross cache lines (assumes
    831832     *  CODEC_NODES_MAX is 32). */
    832     uint8_t const   abPadding1[CODEC_NODES_MAX - 16];
     833    uint8_t const   abPadding1[CODEC_NODES_MAX - 15];
    833834
    834835    /** @name Node classifications.
    … …  
    837838     *       nodes.
    838839     * @{ */
    839     uint8_t const   abPorts[CODEC_NODES_MAX];
    840     uint8_t const   abDacs[CODEC_NODES_MAX];
    841     uint8_t const   abAdcVols[CODEC_NODES_MAX];
    842     uint8_t const   abAdcs[CODEC_NODES_MAX];
    843     uint8_t const   abAdcMuxs[CODEC_NODES_MAX];
    844     uint8_t const   abPcbeeps[CODEC_NODES_MAX];
    845     uint8_t const   abSpdifIns[CODEC_NODES_MAX];
    846     uint8_t const   abSpdifOuts[CODEC_NODES_MAX];
    847     uint8_t const   abDigInPins[CODEC_NODES_MAX];
    848     uint8_t const   abDigOutPins[CODEC_NODES_MAX];
    849     uint8_t const   abCds[CODEC_NODES_MAX];
    850     uint8_t const   abVolKnobs[CODEC_NODES_MAX];
    851     uint8_t const   abReserveds[CODEC_NODES_MAX];
     840    uint8_t         abPorts[CODEC_NODES_MAX];
     841    uint8_t         abDacs[CODEC_NODES_MAX];
     842    uint8_t         abAdcVols[CODEC_NODES_MAX];
     843    uint8_t         abAdcs[CODEC_NODES_MAX];
     844    uint8_t         abAdcMuxs[CODEC_NODES_MAX];
     845    uint8_t         abPcbeeps[CODEC_NODES_MAX];
     846    uint8_t         abSpdifIns[CODEC_NODES_MAX];
     847    uint8_t         abSpdifOuts[CODEC_NODES_MAX];
     848    uint8_t         abDigInPins[CODEC_NODES_MAX];
     849    uint8_t         abDigOutPins[CODEC_NODES_MAX];
     850    uint8_t         abCds[CODEC_NODES_MAX];
     851    uint8_t         abVolKnobs[CODEC_NODES_MAX];
     852    uint8_t         abReserveds[CODEC_NODES_MAX];
    852853    /** @} */
    853854
    854855    /** The CODEC_NODE_CLS_XXX flags for each node. */
    855     uint16_t const  afNodeClassifications[CODEC_NODES_MAX];
    856 
    857     CODECNODE       aNodes[CODEC_NODES_MAX];
    858 
    859     STAMCOUNTER     StatLookupsR3;
    860     uint64_t const  au64Padding3[7];
     856    uint16_t        afNodeClassifications[CODEC_NODES_MAX];
     857} HDACODECCFG;
     858AssertCompileMemberAlignment(HDACODECCFG, abPorts, CODEC_NODES_MAX);
     859
     860
     861/**
     862 * HDA codec state (ring-3, no shared state).
     863 */
     864typedef struct HDACODECR3
     865{
     866    /** The codec configuration - initialized at construction time. */
     867    HDACODECCFG const   Cfg;
     868    /** The node data. */
     869    CODECNODE           aNodes[CODEC_NODES_MAX];
     870    /** Statistics. */
     871    STAMCOUNTER         StatLookupsR3;
     872    /** Size alignment padding. */
     873    uint64_t const      au64Padding1[7];
    861874} HDACODECR3;
    862875AssertCompile(RT_IS_POWER_OF_TWO(CODEC_NODES_MAX));
    863 AssertCompileMemberAlignment(HDACODECR3, abPorts, CODEC_NODES_MAX);
    864876AssertCompileMemberAlignment(HDACODECR3, aNodes, 64);
    865877AssertCompileSizeAlignment(HDACODECR3, 8);
Note: See TracChangeset for help on using the changeset viewer.

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