VirtualBox

Changeset 90119 in vbox for trunk


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

DevHdaCodec: Looping over node index arrays must do proper bound checking (two cases). Doxygen and similar cleanups. bugref:9890

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r89887 r90119  
    145145
    146146
    147 
    148 #if 0 /* unused */
    149 static DECLCALLBACK(void) stac9220DbgNodes(PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs)
    150 {
    151     RT_NOREF(pszArgs);
    152     uint8_t const cTotalNodes = RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
    153     for (uint8_t i = 1; i < cTotalNodes; i++)
    154     {
    155         PCODECNODE pNode = &pThis->aNodes[i];
    156         AMPLIFIER *pAmp = &pNode->dac.B_params;
    157 
    158         uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) & 0x7f;
    159         uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) & 0x7f;
    160 
    161         pHlp->pfnPrintf(pHlp, "0x%x: lVol=%RU8, rVol=%RU8\n", i, lVol, rVol);
    162     }
    163 }
    164 #endif
    165 
     147/*********************************************************************************************************************************
     148*   STAC9220 Constructor / Reset                                                                                                 *
     149*********************************************************************************************************************************/
    166150
    167151/**
    … …  
    741725}
    742726
     727
    743728/**
    744729 * Resets the codec with all its connected nodes.
    … …  
    824809#endif /* IN_RING3 */
    825810
     811
     812/*********************************************************************************************************************************
     813*   Common Helpers                                                                                                               *
     814*********************************************************************************************************************************/
     815
    826816/*
    827817 * Some generic predicate functions.
    828818 */
    829 
    830 #define DECLISNODEOFTYPE(type)                                              \
    831     DECLINLINE(bool) hdaCodecIs##type##Node(PHDACODEC pThis, uint8_t cNode) \
    832     {                                                                       \
    833         Assert(pThis->au8##type##s);                                        \
    834         for (int i = 0; pThis->au8##type##s[i] != 0; ++i)                   \
    835             if (pThis->au8##type##s[i] == cNode)                            \
    836                 return true;                                                \
    837         return false;                                                       \
     819#define HDA_CODEC_IS_NODE_OF_TYPE_FUNC(a_Type) \
     820    DECLINLINE(bool) hdaCodecIs##a_Type##Node(PHDACODEC pThis, uint8_t idNode) \
     821    { \
     822        Assert(pThis->au8##a_Type##s); \
     823        for (uintptr_t i = 0; i < RT_ELEMENTS(pThis->au8##a_Type##s) && pThis->au8##a_Type##s[i] != 0; i++) \
     824            if (pThis->au8##a_Type##s[i] == idNode) \
     825                return true; \
     826        return false; \
    838827    }
    839828/* hdaCodecIsPortNode */
    840 DECLISNODEOFTYPE(Port)
     829HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Port)
    841830/* hdaCodecIsDacNode */
    842 DECLISNODEOFTYPE(Dac)
     831HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Dac)
    843832/* hdaCodecIsAdcVolNode */
    844 DECLISNODEOFTYPE(AdcVol)
     833HDA_CODEC_IS_NODE_OF_TYPE_FUNC(AdcVol)
    845834/* hdaCodecIsAdcNode */
    846 DECLISNODEOFTYPE(Adc)
     835HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Adc)
    847836/* hdaCodecIsAdcMuxNode */
    848 DECLISNODEOFTYPE(AdcMux)
     837HDA_CODEC_IS_NODE_OF_TYPE_FUNC(AdcMux)
    849838/* hdaCodecIsPcbeepNode */
    850 DECLISNODEOFTYPE(Pcbeep)
     839HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Pcbeep)
    851840/* hdaCodecIsSpdifOutNode */
    852 DECLISNODEOFTYPE(SpdifOut)
     841HDA_CODEC_IS_NODE_OF_TYPE_FUNC(SpdifOut)
    853842/* hdaCodecIsSpdifInNode */
    854 DECLISNODEOFTYPE(SpdifIn)
     843HDA_CODEC_IS_NODE_OF_TYPE_FUNC(SpdifIn)
    855844/* hdaCodecIsDigInPinNode */
    856 DECLISNODEOFTYPE(DigInPin)
     845HDA_CODEC_IS_NODE_OF_TYPE_FUNC(DigInPin)
    857846/* hdaCodecIsDigOutPinNode */
    858 DECLISNODEOFTYPE(DigOutPin)
     847HDA_CODEC_IS_NODE_OF_TYPE_FUNC(DigOutPin)
    859848/* hdaCodecIsCdNode */
    860 DECLISNODEOFTYPE(Cd)
     849HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Cd)
    861850/* hdaCodecIsVolKnobNode */
    862 DECLISNODEOFTYPE(VolKnob)
     851HDA_CODEC_IS_NODE_OF_TYPE_FUNC(VolKnob)
    863852/* hdaCodecIsReservedNode */
    864 DECLISNODEOFTYPE(Reserved)
     853HDA_CODEC_IS_NODE_OF_TYPE_FUNC(Reserved)
    865854
    866855#ifdef IN_RING3
    … …  
    937926
    938927
    939 /*
    940  * Verb processor functions.
    941  */
     928/*********************************************************************************************************************************
     929*   Verb Processor Functions.                                                                                                    *
     930*********************************************************************************************************************************/
    942931#if 0 /* unused */
    943932
     933/**
     934 * @interface_method_impl{CODECVERB, pfn, Unimplemented}
     935 */
    944936static DECLCALLBACK(int) vrbProcUnimplemented(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    945937{
    … …  
    951943}
    952944
     945
     946/**
     947 * @interface_method_impl{CODECVERB, pfn, ???}
     948 */
    953949static DECLCALLBACK(int) vrbProcBreak(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    954950{
    … …  
    961957#endif /* unused */
    962958
    963 
    964 /* B-- */
     959/**
     960 * @interface_method_impl{CODECVERB, pfn, b--}
     961 */
    965962static DECLCALLBACK(int) vrbProcGetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    966963{
    … …  
    975972    if (hdaCodecIsDacNode(pThis, CODEC_NID(cmd)))
    976973        *pResp = AMPLIFIER_REGISTER(pNode->dac.B_params,
    977                             CODEC_GET_AMP_DIRECTION(cmd),
    978                             CODEC_GET_AMP_SIDE(cmd),
    979                             u8Index);
     974                                    CODEC_GET_AMP_DIRECTION(cmd),
     975                                    CODEC_GET_AMP_SIDE(cmd),
     976                                    u8Index);
    980977    else if (hdaCodecIsAdcVolNode(pThis, CODEC_NID(cmd)))
    981978        *pResp = AMPLIFIER_REGISTER(pNode->adcvol.B_params,
    982                             CODEC_GET_AMP_DIRECTION(cmd),
    983                             CODEC_GET_AMP_SIDE(cmd),
    984                             u8Index);
     979                                    CODEC_GET_AMP_DIRECTION(cmd),
     980                                    CODEC_GET_AMP_SIDE(cmd),
     981                                    u8Index);
    985982    else if (hdaCodecIsAdcMuxNode(pThis, CODEC_NID(cmd)))
    986983        *pResp = AMPLIFIER_REGISTER(pNode->adcmux.B_params,
    987                             CODEC_GET_AMP_DIRECTION(cmd),
    988                             CODEC_GET_AMP_SIDE(cmd),
    989                             u8Index);
     984                                    CODEC_GET_AMP_DIRECTION(cmd),
     985                                    CODEC_GET_AMP_SIDE(cmd),
     986                                    u8Index);
    990987    else if (hdaCodecIsPcbeepNode(pThis, CODEC_NID(cmd)))
    991988        *pResp = AMPLIFIER_REGISTER(pNode->pcbeep.B_params,
    992                             CODEC_GET_AMP_DIRECTION(cmd),
    993                             CODEC_GET_AMP_SIDE(cmd),
    994                             u8Index);
     989                                    CODEC_GET_AMP_DIRECTION(cmd),
     990                                    CODEC_GET_AMP_SIDE(cmd),
     991                                    u8Index);
    995992    else if (hdaCodecIsPortNode(pThis, CODEC_NID(cmd)))
    996993        *pResp = AMPLIFIER_REGISTER(pNode->port.B_params,
    997                             CODEC_GET_AMP_DIRECTION(cmd),
    998                             CODEC_GET_AMP_SIDE(cmd),
    999                             u8Index);
     994                                    CODEC_GET_AMP_DIRECTION(cmd),
     995                                    CODEC_GET_AMP_SIDE(cmd),
     996                                    u8Index);
    1000997    else if (hdaCodecIsAdcNode(pThis, CODEC_NID(cmd)))
    1001998        *pResp = AMPLIFIER_REGISTER(pNode->adc.B_params,
    1002                             CODEC_GET_AMP_DIRECTION(cmd),
    1003                             CODEC_GET_AMP_SIDE(cmd),
    1004                             u8Index);
     999                                    CODEC_GET_AMP_DIRECTION(cmd),
     1000                                    CODEC_GET_AMP_SIDE(cmd),
     1001                                    u8Index);
    10051002    else
    10061003        LogRel2(("HDA: Warning: Unhandled get amplifier command: 0x%x (NID=0x%x [%RU8])\n", cmd, CODEC_NID(cmd), CODEC_NID(cmd)));
    … …  
    10091006}
    10101007
     1008
     1009/**
     1010 * @interface_method_impl{CODECVERB, pfn, ???}
     1011 */
    10111012static DECLCALLBACK(int) vrbProcGetParameter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    10121013{
    … …  
    10251026}
    10261027
    1027 /* F01 */
     1028
     1029/**
     1030 * @interface_method_impl{CODECVERB, pfn, f01}
     1031 */
    10281032static DECLCALLBACK(int) vrbProcGetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    10291033{
    … …  
    10471051}
    10481052
    1049 /* 701 */
     1053
     1054/**
     1055 * @interface_method_impl{CODECVERB, pfn, 701}
     1056 */
    10501057static DECLCALLBACK(int) vrbProcSetConSelectCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    10511058{
    … …  
    10731080}
    10741081
    1075 /* F07 */
     1082
     1083/**
     1084 * @interface_method_impl{CODECVERB, pfn, f07}
     1085 */
    10761086static DECLCALLBACK(int) vrbProcGetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    10771087{
    … …  
    10971107}
    10981108
    1099 /* 707 */
     1109
     1110/**
     1111 * @interface_method_impl{CODECVERB, pfn, 707}
     1112 */
    11001113static DECLCALLBACK(int) vrbProcSetPinCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    11011114{
    … …  
    11261139}
    11271140
    1128 /* F08 */
     1141
     1142/**
     1143 * @interface_method_impl{CODECVERB, pfn, f08}
     1144 */
    11291145static DECLCALLBACK(int) vrbProcGetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    11301146{
    … …  
    11501166}
    11511167
    1152 /* 708 */
     1168
     1169/**
     1170 * @interface_method_impl{CODECVERB, pfn, 708}
     1171 */
    11531172static DECLCALLBACK(int) vrbProcSetUnsolicitedEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    11541173{
    … …  
    11781197}
    11791198
    1180 /* F09 */
     1199
     1200/**
     1201 * @interface_method_impl{CODECVERB, pfn, f09}
     1202 */
    11811203static DECLCALLBACK(int) vrbProcGetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    11821204{
    … …  
    11971219}
    11981220
    1199 /* 709 */
     1221
     1222/**
     1223 * @interface_method_impl{CODECVERB, pfn, 709}
     1224 */
    12001225static DECLCALLBACK(int) vrbProcSetPinSense(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12011226{
    … …  
    12171242}
    12181243
     1244
     1245/**
     1246 * @interface_method_impl{CODECVERB, pfn, ???}
     1247 */
    12191248static DECLCALLBACK(int) vrbProcGetConnectionListEntry(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12201249{
    … …  
    12321261}
    12331262
    1234 /* F03 */
     1263
     1264/**
     1265 * @interface_method_impl{CODECVERB, pfn, f03}
     1266 */
    12351267static DECLCALLBACK(int) vrbProcGetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12361268{
    … …  
    12441276}
    12451277
    1246 /* 703 */
     1278
     1279/**
     1280 * @interface_method_impl{CODECVERB, pfn, 703}
     1281 */
    12471282static DECLCALLBACK(int) vrbProcSetProcessingState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12481283{
    … …  
    12551290}
    12561291
    1257 /* F0D */
     1292
     1293/**
     1294 * @interface_method_impl{CODECVERB, pfn, f0d}
     1295 */
    12581296static DECLCALLBACK(int) vrbProcGetDigitalConverter(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12591297{
    … …  
    12691307}
    12701308
     1309
    12711310static int codecSetDigitalConverter(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
    12721311{
    … …  
    12801319}
    12811320
    1282 /* 70D */
     1321
     1322/**
     1323 * @interface_method_impl{CODECVERB, pfn, 70d}
     1324 */
    12831325static DECLCALLBACK(int) vrbProcSetDigitalConverter1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12841326{
    … …  
    12871329}
    12881330
    1289 /* 70E */
     1331
     1332/**
     1333 * @interface_method_impl{CODECVERB, pfn, 70e}
     1334 */
    12901335static DECLCALLBACK(int) vrbProcSetDigitalConverter2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12911336{
    … …  
    12941339}
    12951340
    1296 /* F20 */
     1341
     1342/**
     1343 * @interface_method_impl{CODECVERB, pfn, f20}
     1344 */
    12971345static DECLCALLBACK(int) vrbProcGetSubId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    12981346{
    … …  
    13141362}
    13151363
     1364
    13161365static int codecSetSubIdX(PHDACODEC pThis, uint32_t cmd, uint8_t u8Offset)
    13171366{
    … …  
    13331382}
    13341383
    1335 /* 720 */
     1384
     1385/**
     1386 * @interface_method_impl{CODECVERB, pfn, 720}
     1387 */
    13361388static DECLCALLBACK(int) vrbProcSetSubId0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13371389{
    … …  
    13411393}
    13421394
    1343 /* 721 */
     1395
     1396/**
     1397 * @interface_method_impl{CODECVERB, pfn, 721}
     1398 */
    13441399static DECLCALLBACK(int) vrbProcSetSubId1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13451400{
    … …  
    13491404}
    13501405
    1351 /* 722 */
     1406
     1407/**
     1408 * @interface_method_impl{CODECVERB, pfn, 722}
     1409 */
    13521410static DECLCALLBACK(int) vrbProcSetSubId2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13531411{
    … …  
    13571415}
    13581416
    1359 /* 723 */
     1417
     1418/**
     1419 * @interface_method_impl{CODECVERB, pfn, 723}
     1420 */
    13601421static DECLCALLBACK(int) vrbProcSetSubId3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13611422{
    … …  
    13651426}
    13661427
     1428
     1429/**
     1430 * @interface_method_impl{CODECVERB, pfn, ???}
     1431 */
    13671432static DECLCALLBACK(int) vrbProcReset(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13681433{
    … …  
    13841449}
    13851450
    1386 /* F05 */
     1451
     1452/**
     1453 * @interface_method_impl{CODECVERB, pfn, f05}
     1454 */
    13871455static DECLCALLBACK(int) vrbProcGetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    13881456{
    … …  
    14141482}
    14151483
    1416 /* 705 */
    14171484#if 1
     1485
     1486/**
     1487 * @interface_method_impl{CODECVERB, pfn, 705}
     1488 */
    14181489static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    14191490{
    … …  
    14691540        LogFunc(("Propagating Act=D%RU8 (AFG), Set=D%RU8 to all AFG child nodes ...\n", uAFGPwrAct, uPwrCmd));
    14701541
    1471 #define PROPAGATE_PWR_STATE(_aList, _aMember) \
    1472         { \
    1473             const uint8_t *pu8NodeIndex = &_aList[0]; \
    1474             while (*(++pu8NodeIndex)) \
     1542#define PROPAGATE_PWR_STATE(a_abList, a_Member) \
     1543        do { \
     1544            for (uintptr_t idxList = 0; idxList < RT_ELEMENTS(a_abList); idxList++) \
    14751545            { \
    1476                 pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param = \
    1477                     CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd); \
    1478                 LogFunc(("\t[NID0x%02x]: Act=D%RU8, Set=D%RU8\n", *pu8NodeIndex, \
    1479                          CODEC_F05_ACT(pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param), \
    1480                          CODEC_F05_SET(pThis->aNodes[*pu8NodeIndex]._aMember.u32F05_param))); \
     1546                uint8_t const idxNode = a_abList[idxList]; \
     1547                if (idxNode) \
     1548                { \
     1549                    pThis->aNodes[idxNode].a_Member.u32F05_param = CODEC_MAKE_F05(fReset, fStopOk, 0, uAFGPwrAct, uPwrCmd); \
     1550                    LogFunc(("\t[NID0x%02x]: Act=D%RU8, Set=D%RU8\n", idxNode, \
     1551                             CODEC_F05_ACT(pThis->aNodes[idxNode].a_Member.u32F05_param), \
     1552                             CODEC_F05_SET(pThis->aNodes[idxNode].a_Member.u32F05_param))); \
     1553                } \
     1554                else \
     1555                    break; \
    14811556            } \
    1482         }
     1557        } while (0)
    14831558
    14841559        PROPAGATE_PWR_STATE(pThis->au8Dacs,       dac);
    … …  
    15071582    return VINF_SUCCESS;
    15081583}
     1584
    15091585#else
     1586
    15101587DECLINLINE(void) codecPropogatePowerState(uint32_t *pu32F05_param)
    15111588{
    … …  
    15191596}
    15201597
     1598
     1599/**
     1600 * @interface_method_impl{CODECVERB, pfn, 705}
     1601 */
    15211602static DECLCALLBACK(int) vrbProcSetPowerState(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    15221603{
    … …  
    15871668    return VINF_SUCCESS;
    15881669}
     1670
    15891671#endif
    15901672
    1591 /* F06 */
     1673/**
     1674 * @interface_method_impl{CODECVERB, pfn, f06}
     1675 */
    15921676static DECLCALLBACK(int) vrbProcGetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    15931677{
    … …  
    16141698}
    16151699
    1616 /* A0 */
     1700
     1701/**
     1702 * @interface_method_impl{CODECVERB, pfn, a0}
     1703 */
    16171704static DECLCALLBACK(int) vrbProcGetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    16181705{
    … …  
    16361723}
    16371724
    1638 /* Also see section 3.7.1. */
     1725
     1726/**
     1727 * @interface_method_impl{CODECVERB, pfn, ??? - Also see section 3.7.1.}
     1728 */
    16391729static DECLCALLBACK(int) vrbProcSetConverterFormat(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    16401730{
    … …  
    16561746}
    16571747
    1658 /* F0C */
     1748
     1749/**
     1750 * @interface_method_impl{CODECVERB, pfn, f0c}
     1751 */
    16591752static DECLCALLBACK(int) vrbProcGetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    16601753{
    … …  
    16741767}
    16751768
    1676 /* 70C */
     1769
     1770/**
     1771 * @interface_method_impl{CODECVERB, pfn, 70c}
     1772 */
    16771773static DECLCALLBACK(int) vrbProcSetEAPD_BTLEnabled(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    16781774{
    … …  
    16961792}
    16971793
    1698 /* F0F */
     1794
     1795/**
     1796 * @interface_method_impl{CODECVERB, pfn, f0f}
     1797 */
    16991798static DECLCALLBACK(int) vrbProcGetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17001799{
    … …  
    17101809}
    17111810
    1712 /* 70F */
     1811
     1812/**
     1813 * @interface_method_impl{CODECVERB, pfn, 70f}
     1814 */
    17131815static DECLCALLBACK(int) vrbProcSetVolumeKnobCtrl(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17141816{
    … …  
    17281830}
    17291831
    1730 /* F15 */
     1832
     1833/**
     1834 * @interface_method_impl{CODECVERB, pfn, f15}
     1835 */
    17311836static DECLCALLBACK(int) vrbProcGetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17321837{
    … …  
    17361841}
    17371842
    1738 /* 715 */
     1843
     1844/**
     1845 * @interface_method_impl{CODECVERB, pfn, 715}
     1846 */
    17391847static DECLCALLBACK(int) vrbProcSetGPIOData(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17401848{
    … …  
    17441852}
    17451853
    1746 /* F16 */
     1854
     1855/**
     1856 * @interface_method_impl{CODECVERB, pfn, f16}
     1857 */
    17471858static DECLCALLBACK(int) vrbProcGetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17481859{
    … …  
    17521863}
    17531864
    1754 /* 716 */
     1865
     1866/**
     1867 * @interface_method_impl{CODECVERB, pfn, 716}
     1868 */
    17551869static DECLCALLBACK(int) vrbProcSetGPIOEnableMask(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17561870{
    … …  
    17601874}
    17611875
    1762 /* F17 */
     1876
     1877/**
     1878 * @interface_method_impl{CODECVERB, pfn, f17}
     1879 */
    17631880static DECLCALLBACK(int) vrbProcGetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17641881{
    … …  
    17751892}
    17761893
    1777 /* 717 */
     1894
     1895/**
     1896 * @interface_method_impl{CODECVERB, pfn, 717}
     1897 */
    17781898static DECLCALLBACK(int) vrbProcSetGPIODirection(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17791899{
    … …  
    17931913}
    17941914
    1795 /* F1C */
     1915
     1916/**
     1917 * @interface_method_impl{CODECVERB, pfn, f1c}
     1918 */
    17961919static DECLCALLBACK(int) vrbProcGetConfig(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    17971920{
    … …  
    18411964}
    18421965
    1843 /* 71C */
     1966
     1967/**
     1968 * @interface_method_impl{CODECVERB, pfn, 71c}
     1969 */
    18441970static DECLCALLBACK(int) vrbProcSetConfig0(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18451971{
    … …  
    18491975}
    18501976
    1851 /* 71D */
     1977
     1978/**
     1979 * @interface_method_impl{CODECVERB, pfn, 71d}
     1980 */
    18521981static DECLCALLBACK(int) vrbProcSetConfig1(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18531982{
    … …  
    18571986}
    18581987
    1859 /* 71E */
     1988
     1989/**
     1990 * @interface_method_impl{CODECVERB, pfn, 71e}
     1991 */
    18601992static DECLCALLBACK(int) vrbProcSetConfig2(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18611993{
    … …  
    18651997}
    18661998
    1867 /* 71E */
     1999
     2000/**
     2001 * @interface_method_impl{CODECVERB, pfn, 71e}
     2002 */
    18682003static DECLCALLBACK(int) vrbProcSetConfig3(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18692004{
    … …  
    18732008}
    18742009
    1875 /* F04 */
     2010
     2011/**
     2012 * @interface_method_impl{CODECVERB, pfn, f04}
     2013 */
    18762014static DECLCALLBACK(int) vrbProcGetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18772015{
    … …  
    18872025}
    18882026
    1889 /* 704 */
     2027
     2028/**
     2029 * @interface_method_impl{CODECVERB, pfn, 704}
     2030 */
    18902031static DECLCALLBACK(int) vrbProcSetSDISelect(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    18912032{
    … …  
    19072048#ifdef IN_RING3
    19082049
    1909 /* 3-- */
     2050/**
     2051 * @interface_method_impl{CODECVERB, pfn, 3--}
     2052 */
    19102053static DECLCALLBACK(int) vrbProcR3SetAmplifier(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    19112054{
    … …  
    19722115}
    19732116
    1974 /* 706 */
     2117
     2118/**
     2119 * @interface_method_impl{CODECVERB, pfn, 706}
     2120 */
    19752121static DECLCALLBACK(int) vrbProcR3SetStreamId(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t cmd, uint64_t *pResp)
    19762122{
    … …  
    21052251
    21062252
     2253/**
     2254 * Implements
     2255 */
     2256static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
     2257{
     2258    /*
     2259     * Clear the return value and assert some sanity.
     2260     */
     2261    AssertPtr(puResp);
     2262    *puResp = 0;
     2263    AssertPtr(pThis);
     2264    AssertPtr(pThisCC);
     2265    AssertMsgReturn(CODEC_CAD(uCmd) == pThis->id,
     2266                    ("Unknown codec address 0x%x\n", CODEC_CAD(uCmd)),
     2267                    VERR_INVALID_PARAMETER);
     2268    uint32_t const uCmdData = CODEC_VERBDATA(uCmd);
     2269    AssertMsgReturn(   uCmdData != 0
     2270                    && CODEC_NID(uCmd) < RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes)),
     2271                    ("[NID0x%02x] Unknown / invalid node or data (0x%x)\n", CODEC_NID(uCmd), uCmdData),
     2272                    VERR_INVALID_PARAMETER);
     2273    STAM_COUNTER_INC(&pThis->CTX_SUFF(StatLookups));
     2274
     2275    /*
     2276     * Do a binary lookup of the verb.
     2277     * Note! if we want other verb tables, add a table selector before the loop.
     2278     */
     2279    size_t iFirst = 0;
     2280    size_t iEnd   = RT_ELEMENTS(g_aCodecVerbs);
     2281    for (;;)
     2282    {
     2283        size_t const   iCur  = iFirst + (iEnd - iFirst) / 2;
     2284        uint32_t const uVerb = g_aCodecVerbs[iCur].uVerb;
     2285        if (uCmdData < uVerb)
     2286        {
     2287            if (iCur > iFirst)
     2288                iEnd = iCur;
     2289            else
     2290                break;
     2291        }
     2292        else if ((uCmdData & g_aCodecVerbs[iCur].fMask) != uVerb)
     2293        {
     2294            if (iCur + 1 < iEnd)
     2295                iFirst = iCur + 1;
     2296            else
     2297                break;
     2298        }
     2299        else
     2300        {
     2301            /*
     2302             * Found it!  Run the callback and return.
     2303             */
     2304#ifndef IN_RING3
     2305            if (!g_aCodecVerbs[iCur].pfn)
     2306            {
     2307                Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> VERR_INVALID_CONTEXT\n", /* -> ring-3 */
     2308                          CODEC_NID(uCmd), g_aCodecVerbs[iCur].uVerb, g_aCodecVerbs[iCur].pszName, CODEC_VERB_PAYLOAD8(uCmd)));
     2309                return VERR_INVALID_CONTEXT;
     2310            }
     2311#endif
     2312            AssertPtrReturn(g_aCodecVerbs[iCur].pfn, VERR_INTERNAL_ERROR_5); /* Paranoia^2. */
     2313
     2314            int rc = g_aCodecVerbs[iCur].pfn(pThis, pThisCC, uCmd, puResp);
     2315            AssertRC(rc);
     2316            Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> 0x%x\n",
     2317                      CODEC_NID(uCmd), g_aCodecVerbs[iCur].uVerb, g_aCodecVerbs[iCur].pszName, CODEC_VERB_PAYLOAD8(uCmd), *puResp));
     2318            return rc;
     2319        }
     2320    }
     2321
     2322#ifdef VBOX_STRICT
     2323    for (size_t i = 0; i < RT_ELEMENTS(g_aCodecVerbs); i++)
     2324    {
     2325        AssertMsg(i == 0 || g_aCodecVerbs[i - 1].uVerb < g_aCodecVerbs[i].uVerb,
     2326                  ("i=%#x uVerb[-1]=%#x uVerb=%#x - buggy table!\n", i, g_aCodecVerbs[i - 1].uVerb, g_aCodecVerbs[i].uVerb));
     2327        AssertMsg((uCmdData & g_aCodecVerbs[i].fMask) != g_aCodecVerbs[i].uVerb,
     2328                  ("i=%#x uVerb=%#x uCmd=%#x - buggy binary search or table!\n", i, g_aCodecVerbs[i].uVerb, uCmd));
     2329    }
     2330#endif
     2331    LogFunc(("[NID0x%02x] Callback for %x not found\n", CODEC_NID(uCmd), CODEC_VERBDATA(uCmd)));
     2332    return VERR_NOT_FOUND;
     2333}
     2334
     2335
     2336/*********************************************************************************************************************************
     2337*   Debug                                                                                                                        *
     2338*********************************************************************************************************************************/
    21072339#ifdef IN_RING3
    21082340
    … …  
    21222354typedef CODECDEBUG *PCODECDEBUG;
    21232355
    2124 #define CODECDBG_INDENT         pInfo->uLevel++;
    2125 #define CODECDBG_UNINDENT       if (pInfo->uLevel) pInfo->uLevel--;
    2126 
    2127 #define CODECDBG_PRINT(...)     pInfo->pHlp->pfnPrintf(pInfo->pHlp, __VA_ARGS__)
    2128 #define CODECDBG_PRINTI(...)    codecDbgPrintf(pInfo, __VA_ARGS__)
     2356# define CODECDBG_INDENT        pInfo->uLevel++;
     2357# define CODECDBG_UNINDENT      if (pInfo->uLevel) pInfo->uLevel--;
     2358
     2359# define CODECDBG_PRINT(...)    pInfo->pHlp->pfnPrintf(pInfo->pHlp, __VA_ARGS__)
     2360# define CODECDBG_PRINTI(...)   codecDbgPrintf(pInfo, __VA_ARGS__)
     2361
    21292362
    21302363/** Wrapper around DBGFINFOHLP::pfnPrintf that adds identation. */
    … …  
    21372370}
    21382371
     2372
    21392373/** Power state */
    21402374static void codecDbgPrintNodeRegF05(PCODECDEBUG pInfo, uint32_t u32Reg)
    … …  
    21442378}
    21452379
     2380
    21462381static void codecDbgPrintNodeRegA(PCODECDEBUG pInfo, uint32_t u32Reg)
    21472382{
    21482383    codecDbgPrintf(pInfo, "RegA: %x\n", u32Reg);
    21492384}
     2385
    21502386
    21512387static void codecDbgPrintNodeRegF00(PCODECDEBUG pInfo, uint32_t *paReg00)
    … …  
    21742410}
    21752411
     2412
    21762413static void codecDbgPrintNodeAmp(PCODECDEBUG pInfo, uint32_t *paReg, uint8_t uIdx, uint8_t uDir)
    21772414{
    … …  
    21912428}
    21922429
     2430
    21932431# if 0 /* unused */
    21942432static void codecDbgPrintNodeConnections(PCODECDEBUG pInfo, PCODECNODE pNode)
    … …  
    22022440# endif
    22032441
     2442
    22042443static void codecDbgPrintNode(PCODECDEBUG pInfo, PCODECNODE pNode, bool fRecursive)
    22052444{
    … …  
    22072446
    22082447    if (pNode->node.uID == STAC9220_NID_ROOT)
    2209     {
    22102448        CODECDBG_PRINT("ROOT\n");
    2211     }
    22122449    else if (pNode->node.uID == STAC9220_NID_AFG)
    22132450    {
    … …  
    22192456    }
    22202457    else if (hdaCodecIsPortNode(pInfo->pThis, pNode->node.uID))
    2221     {
    22222458        CODECDBG_PRINT("PORT\n");
    2223     }
    22242459    else if (hdaCodecIsDacNode(pInfo->pThis, pNode->node.uID))
    22252460    {
    … …  
    23122547}
    23132548
     2549
    23142550static DECLCALLBACK(void) codecR3DbgListNodes(PHDACODEC pThis, PHDACODECR3 pThisCC, PCDBGFINFOHLP pHlp, const char *pszArgs)
    23152551{
    … …  
    23182554    pHlp->pfnPrintf(pHlp, "HDA LINK / INPUTS\n");
    23192555
    2320     CODECDEBUG dbgInfo;
    2321     dbgInfo.pHlp   = pHlp;
    2322     dbgInfo.pThis  = pThis;
    2323     dbgInfo.uLevel = 0;
    2324 
    2325     PCODECDEBUG pInfo = &dbgInfo;
     2556    CODECDEBUG DbgInfo;
     2557    DbgInfo.pHlp   = pHlp;
     2558    DbgInfo.pThis  = pThis;
     2559    DbgInfo.uLevel = 0;
     2560
     2561    PCODECDEBUG pInfo = &DbgInfo;
    23262562
    23272563    CODECDBG_INDENT
    … …  
    23322568            /* Start with all nodes which have connection entries set. */
    23332569            if (CODEC_F00_0E_COUNT(pNode->node.au32F00_param[0xE]))
    2334                 codecDbgPrintNode(&dbgInfo, pNode, true /* fRecursive */);
     2570                codecDbgPrintNode(&DbgInfo, pNode, true /* fRecursive */);
    23352571        }
    23362572    CODECDBG_UNINDENT
    23372573}
    23382574
     2575
    23392576static DECLCALLBACK(void) codecR3DbgSelector(PHDACODEC pThis, PHDACODECR3 pThisCC, PCDBGFINFOHLP pHlp, const char *pszArgs)
    23402577{
    … …  
    23422579}
    23432580
     2581
     2582# if 0 /* unused */
     2583static DECLCALLBACK(void) stac9220DbgNodes(PHDACODEC pThis, PCDBGFINFOHLP pHlp, const char *pszArgs)
     2584{
     2585    RT_NOREF(pszArgs);
     2586    uint8_t const cTotalNodes = RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes));
     2587    for (uint8_t i = 1; i < cTotalNodes; i++)
     2588    {
     2589        PCODECNODE pNode = &pThis->aNodes[i];
     2590        AMPLIFIER *pAmp = &pNode->dac.B_params;
     2591
     2592        uint8_t lVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_LEFT, 0) & 0x7f;
     2593        uint8_t rVol = AMPLIFIER_REGISTER(*pAmp, AMPLIFIER_OUT, AMPLIFIER_RIGHT, 0) & 0x7f;
     2594
     2595        pHlp->pfnPrintf(pHlp, "0x%x: lVol=%RU8, rVol=%RU8\n", i, lVol, rVol);
     2596    }
     2597}
     2598# endif
     2599
    23442600#endif /* IN_RING3 */
    23452601
    2346 /**
    2347  * Implements
    2348  */
    2349 static DECLCALLBACK(int) codecLookup(PHDACODEC pThis, PHDACODECCC pThisCC, uint32_t uCmd, uint64_t *puResp)
    2350 {
    2351     /*
    2352      * Clear the return value and assert some sanity.
    2353      */
    2354     AssertPtr(puResp);
    2355     *puResp = 0;
    2356     AssertPtr(pThis);
    2357     AssertPtr(pThisCC);
    2358     AssertMsgReturn(CODEC_CAD(uCmd) == pThis->id,
    2359                     ("Unknown codec address 0x%x\n", CODEC_CAD(uCmd)),
    2360                     VERR_INVALID_PARAMETER);
    2361     uint32_t const uCmdData = CODEC_VERBDATA(uCmd);
    2362     AssertMsgReturn(   uCmdData != 0
    2363                     && CODEC_NID(uCmd) < RT_MIN(pThis->cTotalNodes, RT_ELEMENTS(pThis->aNodes)),
    2364                     ("[NID0x%02x] Unknown / invalid node or data (0x%x)\n", CODEC_NID(uCmd), uCmdData),
    2365                     VERR_INVALID_PARAMETER);
    2366     STAM_COUNTER_INC(&pThis->CTX_SUFF(StatLookups));
    2367 
    2368     /*
    2369      * Do a binary lookup of the verb.
    2370      * Note! if we want other verb tables, add a table selector before the loop.
    2371      */
    2372     size_t iFirst = 0;
    2373     size_t iEnd   = RT_ELEMENTS(g_aCodecVerbs);
    2374     for (;;)
    2375     {
    2376         size_t const   iCur  = iFirst + (iEnd - iFirst) / 2;
    2377         uint32_t const uVerb = g_aCodecVerbs[iCur].uVerb;
    2378         if (uCmdData < uVerb)
    2379         {
    2380             if (iCur > iFirst)
    2381                 iEnd = iCur;
    2382             else
    2383                 break;
    2384         }
    2385         else if ((uCmdData & g_aCodecVerbs[iCur].fMask) != uVerb)
    2386         {
    2387             if (iCur + 1 < iEnd)
    2388                 iFirst = iCur + 1;
    2389             else
    2390                 break;
    2391         }
    2392         else
    2393         {
    2394             /*
    2395              * Found it!  Run the callback and return.
    2396              */
    2397 #ifndef IN_RING3
    2398             if (!g_aCodecVerbs[iCur].pfn)
    2399             {
    2400                 Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> VERR_INVALID_CONTEXT\n", /* -> ring-3 */
    2401                           CODEC_NID(uCmd), g_aCodecVerbs[iCur].uVerb, g_aCodecVerbs[iCur].pszName, CODEC_VERB_PAYLOAD8(uCmd)));
    2402                 return VERR_INVALID_CONTEXT;
    2403             }
    2404 #endif
    2405             AssertPtrReturn(g_aCodecVerbs[iCur].pfn, VERR_INTERNAL_ERROR_5); /* Paranoia^2. */
    2406 
    2407             int rc = g_aCodecVerbs[iCur].pfn(pThis, pThisCC, uCmd, puResp);
    2408             AssertRC(rc);
    2409             Log3Func(("[NID0x%02x] (0x%x) %s: 0x%x -> 0x%x\n",
    2410                       CODEC_NID(uCmd), g_aCodecVerbs[iCur].uVerb, g_aCodecVerbs[iCur].pszName, CODEC_VERB_PAYLOAD8(uCmd), *puResp));
    2411             return rc;
    2412         }
    2413     }
    2414 
    2415 #ifdef VBOX_STRICT
    2416     for (size_t i = 0; i < RT_ELEMENTS(g_aCodecVerbs); i++)
    2417     {
    2418         AssertMsg(i == 0 || g_aCodecVerbs[i - 1].uVerb < g_aCodecVerbs[i].uVerb,
    2419                   ("i=%#x uVerb[-1]=%#x uVerb=%#x - buggy table!\n", i, g_aCodecVerbs[i - 1].uVerb, g_aCodecVerbs[i].uVerb));
    2420         AssertMsg((uCmdData & g_aCodecVerbs[i].fMask) != g_aCodecVerbs[i].uVerb,
    2421                   ("i=%#x uVerb=%#x uCmd=%#x - buggy binary search or table!\n", i, g_aCodecVerbs[i].uVerb, uCmd));
    2422     }
    2423 #endif
    2424     LogFunc(("[NID0x%02x] Callback for %x not found\n", CODEC_NID(uCmd), CODEC_VERBDATA(uCmd)));
    2425     return VERR_NOT_FOUND;
    2426 }
    2427 
    2428 
    2429 /*
    2430  * APIs exposed to DevHDA.
    2431  */
     2602
     2603
     2604/*********************************************************************************************************************************
     2605*   DevHDA API                                                                                                                   *
     2606*********************************************************************************************************************************/
    24322607
    24332608#ifdef IN_RING3
    … …  
    24692644}
    24702645
     2646
    24712647int hdaR3CodecRemoveStream(PHDACODECR3 pThisCC, PDMAUDIOMIXERCTL enmMixerCtl, bool fImmediate)
    24722648{
    … …  
    24782654    return rc;
    24792655}
     2656
    24802657
    24812658int hdaCodecSaveState(PPDMDEVINS pDevIns, PHDACODEC pThis, PSSMHANDLE pSSM)
    … …  
    24912668}
    24922669
     2670
    24932671int hdaR3CodecLoadState(PPDMDEVINS pDevIns, PHDACODEC pThis, PHDACODECR3 pThisCC, PSSMHANDLE pSSM, uint32_t uVersion)
    24942672{
    … …  
    25552733    return VINF_SUCCESS;
    25562734}
     2735
    25572736
    25582737/**
    … …  
    25872766}
    25882767
     2768
    25892769/**
    25902770 * Constructs a codec (ring-3).
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