VirtualBox

Changeset 31463 in vbox for trunk/src/VBox/Devices/Audio


Ignore:
Timestamp:
Aug 9, 2010 8:37:03 AM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
64544
Message:

Audio/HDA: clean up.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r31459 r31463  
    125125static int codecToAudVolume(struct CODECState *pState);
    126126
    127 static inline void codecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd)
    128 {
    129         *pu32Reg = (*pu32Reg) & ~CODEC_VERB_8BIT_DATA;
    130         *pu32Reg = (*pu32Reg) | (u32Cmd & CODEC_VERB_8BIT_DATA);
     127static inline void codecSetRegister(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset, uint32_t mask)
     128{
     129        Assert((pu32Reg && u8Offset < 32));
     130        *pu32Reg &= ~(mask << u8Offset);
     131        *pu32Reg |= (u32Cmd & mask) << u8Offset;
     132}
     133static inline void codecSetRegisterU8(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
     134{
     135    codecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_8BIT_DATA);
     136}
     137
     138static inline void codecSetRegisterU16(uint32_t *pu32Reg, uint32_t u32Cmd, uint8_t u8Offset)
     139{
     140    codecSetRegister(pu32Reg, u32Cmd, u8Offset, CODEC_VERB_16BIT_DATA);
    131141}
    132142
    … …  
    204214    }
    205215    *pResp = 0;
    206     fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
    207     fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
    208     fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
    209     fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
    210     u8Index = CODEC_SET_AMP_INDEX(cmd);
    211216    PCODECNODE pNode = &pState->pNodes[CODEC_NID(cmd)];
    212217    if (STAC9220_IS_DAC_CMD(cmd))
    … …  
    218223    else if (STAC9220_IS_PCBEEP_CMD(cmd))
    219224        pAmplifier = &pNode->pcbeep.B_params;
    220     if (   (!fIsLeft && !fIsRight)
    221         || (!fIsOut && !fIsIn))
    222         return VINF_SUCCESS;
    223225    Assert(pAmplifier);
    224226    if (pAmplifier)
    225227    {
     228        fIsOut = CODEC_SET_AMP_IS_OUT_DIRECTION(cmd);
     229        fIsIn = CODEC_SET_AMP_IS_IN_DIRECTION(cmd);
     230        fIsRight = CODEC_SET_AMP_IS_RIGHT_SIDE(cmd);
     231        fIsLeft = CODEC_SET_AMP_IS_LEFT_SIDE(cmd);
     232        u8Index = CODEC_SET_AMP_INDEX(cmd);
     233        if (   (!fIsLeft && !fIsRight)
     234            || (!fIsOut && !fIsIn))
     235            return VINF_SUCCESS;
    226236        if (fIsIn)
    227237        {
    228238            if (fIsLeft)
    229                 codecSetRegister(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd);
     239                codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_LEFT, u8Index), cmd, 0);
    230240            if (fIsRight)
    231                 codecSetRegister(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd);
     241                codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_IN, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    232242        }
    233243        if (fIsOut)
    234244        {
    235245            if (fIsLeft)
    236                 codecSetRegister(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd);
     246                codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_LEFT, u8Index), cmd, 0);
    237247            if (fIsRight)
    238                 codecSetRegister(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd);
     248                codecSetRegisterU8(&AMPLIFIER_REGISTER(*pAmplifier, AMPLIFIER_OUT, AMPLIFIER_RIGHT, u8Index), cmd, 0);
    239249        }
    240250        if (CODEC_NID(cmd) == 2)
    … …  
    297307        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digout.u32F01_param;
    298308    Assert((pu32Reg));
    299     if (!pu32Reg)
    300         return VINF_SUCCESS;
    301     *pu32Reg = (*pu32Reg) & ~CODEC_VERB_8BIT_DATA;
    302     *pu32Reg = (*pu32Reg) | (cmd & CODEC_VERB_8BIT_DATA);
     309    if (pu32Reg)
     310        codecSetRegisterU8(pu32Reg, cmd, 0);
    303311    return VINF_SUCCESS;
    304312}
    … …  
    349357        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
    350358    Assert((pu32Reg));
    351     if (!pu32Reg)
    352         return VINF_SUCCESS;
    353     *pu32Reg = (*pu32Reg) & ~CODEC_VERB_8BIT_DATA;
    354     *pu32Reg = (*pu32Reg) | (cmd & CODEC_VERB_8BIT_DATA);
     359    if (pu32Reg)
     360        codecSetRegisterU8(pu32Reg, cmd, 0);
    355361    return VINF_SUCCESS;
    356362}
    … …  
    403409        AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
    404410    Assert(pu32Reg);
    405     if(!pu32Reg)
    406         return VINF_SUCCESS;
    407     *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
    408     *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
     411    if(pu32Reg)
     412        codecSetRegisterU8(pu32Reg, cmd, 0);
    409413    return VINF_SUCCESS;
    410414}
    … …  
    447451        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
    448452    Assert(pu32Reg);
    449     if(!pu32Reg)
    450         return VINF_SUCCESS;
    451     *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
    452     *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
     453    if(pu32Reg)
     454        codecSetRegisterU8(pu32Reg, cmd, 0);
    453455    return VINF_SUCCESS;
    454456}
    … …  
    500502    if (STAC9220_IS_ADC_CMD(cmd))
    501503    {
    502         pState->pNodes[CODEC_NID(cmd)].adc.u32F03_param &= ~CODEC_VERB_8BIT_DATA;
    503         pState->pNodes[CODEC_NID(cmd)].adc.u32F03_param |= cmd & CODEC_VERB_8BIT_DATA;
     504        codecSetRegisterU8(&pState->pNodes[CODEC_NID(cmd)].adc.u32F03_param, cmd, 0);
    504505    }
    505506    return VINF_SUCCESS;
    … …  
    524525}
    525526
     527static int codecSetDigitalConverter(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset, uint64_t *pResp)
     528{
     529    Assert((CODEC_CAD(cmd) == pState->id));
     530    Assert((CODEC_NID(cmd) < STAC9220_NODE_COUNT));
     531    if (CODEC_NID(cmd) >= STAC9220_NODE_COUNT)
     532    {
     533        Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     534        return VINF_SUCCESS;
     535    }
     536    *pResp = 0;
     537    if (STAC9220_IS_SPDIFOUT_CMD(cmd))
     538        codecSetRegisterU8(&pState->pNodes[CODEC_NID(cmd)].spdifout.u32F0d_param, cmd, u8Offset);
     539    else if (STAC9220_IS_SPDIFIN_CMD(cmd))
     540        codecSetRegisterU8(&pState->pNodes[CODEC_NID(cmd)].spdifin.u32F0d_param, cmd, u8Offset);
     541    return VINF_SUCCESS;
     542}
     543
    526544/* 70D */
    527545static int codecSetDigitalConverter1(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    528546{
    529     Assert((CODEC_CAD(cmd) == pState->id));
    530     Assert((CODEC_NID(cmd) < STAC9220_NODE_COUNT));
    531     if (CODEC_NID(cmd) >= STAC9220_NODE_COUNT)
    532     {
    533         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    534         return VINF_SUCCESS;
    535     }
    536     *pResp = 0;
    537     if (STAC9220_IS_SPDIFOUT_CMD(cmd))
    538     {
    539         pState->pNodes[CODEC_NID(cmd)].spdifout.u32F0d_param &= ~CODEC_VERB_8BIT_DATA;
    540         pState->pNodes[CODEC_NID(cmd)].spdifout.u32F0d_param |= cmd & CODEC_VERB_8BIT_DATA;
    541     }
    542     else if (STAC9220_IS_SPDIFIN_CMD(cmd))
    543     {
    544         pState->pNodes[CODEC_NID(cmd)].spdifin.u32F0d_param &= ~CODEC_VERB_8BIT_DATA;
    545         pState->pNodes[CODEC_NID(cmd)].spdifin.u32F0d_param |= cmd & CODEC_VERB_8BIT_DATA;
    546     }
    547     return VINF_SUCCESS;
    548 }
     547    return codecSetDigitalConverter(pState, cmd, 0, pResp);
     548}
     549
    549550/* 70E */
    550551static int codecSetDigitalConverter2(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    551552{
    552     Assert((CODEC_CAD(cmd) == pState->id));
    553     Assert((CODEC_NID(cmd) < STAC9220_NODE_COUNT));
    554     if (CODEC_NID(cmd) >= STAC9220_NODE_COUNT)
    555     {
    556         Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
    557         return VINF_SUCCESS;
    558     }
    559     *pResp = 0;
    560     if (STAC9220_IS_SPDIFOUT_CMD(cmd))
    561     {
    562         pState->pNodes[CODEC_NID(cmd)].spdifout.u32F0d_param &= ~(CODEC_VERB_8BIT_DATA << 8);
    563         pState->pNodes[CODEC_NID(cmd)].spdifout.u32F0d_param |= cmd & (CODEC_VERB_8BIT_DATA << 8);
    564     }
    565     else if (STAC9220_IS_SPDIFIN_CMD(cmd))
    566     {
    567         pState->pNodes[CODEC_NID(cmd)].spdifin.u32F0d_param &= ~(CODEC_VERB_8BIT_DATA << 8);
    568         pState->pNodes[CODEC_NID(cmd)].spdifin.u32F0d_param |= cmd & (CODEC_VERB_8BIT_DATA << 8);
    569     }
    570     return VINF_SUCCESS;
     553    return codecSetDigitalConverter(pState, cmd, 8, pResp);
    571554}
    572555
    … …  
    700683    Assert((pu32addr));
    701684    if (pu32addr)
    702     {
    703         *pu32addr &= ~CODEC_VERB_8BIT_DATA;
    704         *pu32addr |= cmd & CODEC_VERB_8BIT_DATA;
    705     }
     685        codecSetRegisterU8(pu32addr, cmd, 0);
    706686    return VINF_SUCCESS;
    707687}
    … …  
    738718    *pResp = 0;
    739719    if (STAC9220_IS_DAC_CMD(cmd))
    740     {
    741         pState->pNodes[CODEC_NID(cmd)].dac.u32A_param &= ~CODEC_VERB_16BIT_DATA;
    742         pState->pNodes[CODEC_NID(cmd)].dac.u32A_param |= cmd & CODEC_VERB_16BIT_DATA;
    743     }
     720        codecSetRegisterU16(&pState->pNodes[CODEC_NID(cmd)].dac.u32A_param, cmd, 0);
    744721    else if (STAC9220_IS_ADC_CMD(cmd))
    745     {
    746         pState->pNodes[CODEC_NID(cmd)].adc.u32A_param &= ~CODEC_VERB_16BIT_DATA;
    747         pState->pNodes[CODEC_NID(cmd)].adc.u32A_param |= cmd & CODEC_VERB_16BIT_DATA;
    748     }
     722        codecSetRegisterU16(&pState->pNodes[CODEC_NID(cmd)].adc.u32A_param, cmd, 0);
    749723    else if (STAC9220_IS_SPDIFOUT_CMD(cmd))
    750     {
    751         pState->pNodes[CODEC_NID(cmd)].spdifout.u32A_param &= ~CODEC_VERB_16BIT_DATA;
    752         pState->pNodes[CODEC_NID(cmd)].spdifout.u32A_param |= cmd & CODEC_VERB_16BIT_DATA;
    753     }
     724        codecSetRegisterU16(&pState->pNodes[CODEC_NID(cmd)].spdifout.u32A_param, cmd, 0);
    754725    else if (STAC9220_IS_SPDIFIN_CMD(cmd))
    755     {
    756         pState->pNodes[CODEC_NID(cmd)].spdifin.u32A_param &= ~CODEC_VERB_16BIT_DATA;
    757         pState->pNodes[CODEC_NID(cmd)].spdifin.u32A_param |= cmd & CODEC_VERB_16BIT_DATA;
    758     }
     726        codecSetRegisterU16(&pState->pNodes[CODEC_NID(cmd)].spdifin.u32A_param, cmd, 0);
    759727    return VINF_SUCCESS;
    760728}
    … …  
    801769    Assert((pu32Reg));
    802770    if (pu32Reg)
    803     {
    804         *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
    805         *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
    806     }
     771        codecSetRegisterU8(pu32Reg, cmd, 0);
    807772    return VINF_SUCCESS;
    808773}
    … …  
    840805    Assert((pu32Reg));
    841806    if (pu32Reg)
    842     {
    843         *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
    844         *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
    845     }
     807        codecSetRegisterU8(pu32Reg, cmd, 0);
    846808    return VINF_SUCCESS;
    847809}
    … …  
    868830    return VINF_SUCCESS;
    869831}
    870 static int codecSetConfigX(struct CODECState *pState, uint32_t cmd, uint32_t mask)
     832static int codecSetConfigX(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset)
    871833{
    872834    Assert((CODEC_CAD(cmd) == pState->id));
    … …  
    888850    Assert((pu32Reg));
    889851    if (pu32Reg)
    890     {
    891         *pu32Reg &= ~mask;
    892         *pu32Reg |= cmd & mask;
    893     }
     852        codecSetRegisterU8(pu32Reg, cmd, u8Offset);
    894853    return VINF_SUCCESS;
    895854}
    … …  
    897856static int codecSetConfig0 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    898857{
    899     uint32_t mask = CODEC_VERB_8BIT_DATA;
    900     *pResp = 0;
    901     return codecSetConfigX(pState, cmd, mask);
     858    *pResp = 0;
     859    return codecSetConfigX(pState, cmd, 0);
    902860}
    903861/* 71D */
    904862static int codecSetConfig1 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    905863{
    906     uint32_t mask = CODEC_VERB_8BIT_DATA << 8;
    907     *pResp = 0;
    908     return codecSetConfigX(pState, cmd, mask);
     864    *pResp = 0;
     865    return codecSetConfigX(pState, cmd, 8);
    909866}
    910867/* 71E */
    911868static int codecSetConfig2 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    912869{
    913     uint32_t mask = CODEC_VERB_8BIT_DATA << 16;
    914     *pResp = 0;
    915     return codecSetConfigX(pState, cmd, mask);
     870    *pResp = 0;
     871    return codecSetConfigX(pState, cmd, 16);
    916872}
    917873/* 71E */
    918874static int codecSetConfig3 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    919875{
    920     uint32_t mask = CODEC_VERB_8BIT_DATA << 24;
    921     *pResp = 0;
    922     return codecSetConfigX(pState, cmd, mask);
     876    *pResp = 0;
     877    return codecSetConfigX(pState, cmd, 24);
    923878}
    924879
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