VirtualBox

Changeset 33327 in vbox


Ignore:
Timestamp:
Oct 22, 2010 2:36:38 AM (14 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
66907
Message:

Audio/HDA: sound on Mac guest & some clean up.

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

Legend:

Unmodified
Added
Removed

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

    r32933 r33327  
    9595    unconst(pState->cTotalNodes) = 0x1C;
    9696    pState->pfnCodecNodeReset = stac9220ResetNode;
     97    pState->u16VendorId = 0x8384;
     98    pState->u16DeviceId = 0x7680;
    9799    pState->pNodes = (PCODECNODE)RTMemAllocZ(sizeof(CODECNODE) * pState->cTotalNodes);
    98100    pState->fInReset = false;
    … …  
    144146            pNode->node.au32F00_param[0xD] = RT_BIT(31)|(0x5 << 16)|(0xE)<<8;
    145147            pNode->node.au32F00_param[0x12] = RT_BIT(31)|(0x2 << 16)|(0x7f << 8)|0x7f;
    146             pNode->node.au32F00_param[0x11] = 0;
     148            pNode->node.au32F00_param[0x11] = 0xc0000004;
    147149            pNode->node.au32F00_param[0xF] = 0xF;
    148150            pNode->afg.u32F05_param = 0x2 << 4| 0x2; /* PS-Act: D3, PS->Set D3  */
    149             pNode->afg.u32F20_param = 0x83847882;
     151            pNode->afg.u32F20_param = pState->u16VendorId << 16 | pState->u16DeviceId;
    150152            pNode->afg.u32F08_param = 0;
     153            pNode->afg.u32F17_param = 0;
    151154            break;
    152155        case 2:
    … …  
    212215            pNode->node.au32F00_param[0xC] = 0x173f;
    213216            pNode->node.au32F02_param[0] = 0x2;
    214             pNode->port.u32F07_param = RT_BIT(6);
     217            pNode->port.u32F07_param = 0xc0;//RT_BIT(6);
    215218            pNode->port.u32F08_param = 0;
    216219            pNode->port.u32F09_param = RT_BIT(31)|0x9920; /* 39.2 kOm */
    … …  
    231234            pNode->node.au32F02_param[0] = 0x3;
    232235            pNode->node.au32F00_param[0xC] = 0x1737;
    233             pNode->port.u32F09_param = 0;
    234236            pNode->port.u32F07_param = RT_BIT(5);
    235237            if (!pState->fInReset)
    … …  
    238240        case 0xD:
    239241            pNode->node.name = "PortD";
    240             pNode->node.au32F00_param[0xC] = 0x173f;
    241             pNode->port.u32F09_param = 0;
     242            pNode->node.au32F00_param[0xC] = 0x173c;
     243            pNode->port.u32F09_param = 0x173f;
    242244            pNode->port.u32F07_param = RT_BIT(6);
    243245            pNode->node.au32F02_param[0] = 0x2;
    … …  
    245247                pNode->port.u32F1c_param = 0x01013040;  /* Line Out */
    246248        port_init:
     249            pNode->port.u32F09_param = RT_BIT(31)|0x7fffffff;
    247250            pNode->port.u32F08_param = 0;
    248251            pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
    … …  
    253256            pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(7)|RT_BIT(0);
    254257            pNode->port.u32F08_param = 0;
    255             pNode->node.au32F00_param[0xC] = RT_BIT(5)|RT_BIT(2);
     258            pNode->node.au32F00_param[0xC] = 0x34;
     259            pNode->port.u32F09_param = 0;
     260            //pNode->node.au32F00_param[0xC] = RT_BIT(5)|RT_BIT(2);
    256261            pNode->port.u32F07_param = RT_BIT(5);
    257             pNode->port.u32F09_param = RT_BIT(31);
     262            //pNode->port.u32F09_param = RT_BIT(31);
    258263            if (!pState->fInReset)
    259264                pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x50, 0x90, 0xA1, 0x02); /* Microphone */
    … …  
    261266        case 0xF:
    262267            pNode->node.name = "PortF";
    263             pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
     268            pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(2)|RT_BIT(0);
    264269            pNode->node.au32F00_param[0xC] = 0x37;
    265270            pNode->node.au32F00_param[0xE] = 0x1;
    266271            pNode->port.u32F08_param = 0;
    267             pNode->port.u32F07_param = 0;
     272            pNode->port.u32F07_param = 0x40;
    268273            if (!pState->fInReset)
    269274                pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x12, 0x60, 0x11, 0x01);
    270275            pNode->node.au32F02_param[0] = 0x5;
    271             pNode->port.u32F09_param = 0;
     276            pNode->port.u32F09_param = 0x7fffffff;
    272277        break;
    273278        case 0x10:
    … …  
    286291            pNode->node.name = "DigIn_0";
    287292            pNode->node.au32F00_param[9] = (4 << 20)|(3<<16)|RT_BIT(10)|RT_BIT(9)|RT_BIT(7)|RT_BIT(0);
    288             pNode->node.au32F00_param[0xC] = /* RT_BIT(16)|*/ RT_BIT(5)|RT_BIT(2);
     293            pNode->node.au32F00_param[0xC] = RT_BIT(16)| RT_BIT(5)|RT_BIT(2);
    289294            pNode->digin.u32F05_param = 0x3 << 4 | 0x3; /* PS-Act: D3 -> D3 */
    290295            pNode->digin.u32F07_param = 0;
    … …  
    363368            pNode->node.au32F00_param[0x9] = (0x4 << 20)|RT_BIT(9)|RT_BIT(8)|RT_BIT(0);
    364369            pNode->node.au32F00_param[0xE] = 0x1;
     370            pNode->node.au32F00_param[0xC] = 0x10;
    365371            pNode->node.au32F02_param[0] = 0x1a;
    366372            pNode->reserved.u32F07_param = 0;
    367             pNode->reserved.u32F1c_param = 0x400000fb; /* dumped from real stac9220 chip */
     373            pNode->reserved.u32F1c_param = 0x4000000f;
    368374            break;
    369375        default:
    … …  
    374380
    375381/* ALC885 */
    376 const static uint8_t au8Alc889aPorts[] = { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0};
    377 const static uint8_t au8Alc889aDacs[] = { 0x2, 0x3, 0x4, 0x5, 0x25, 0};
    378 const static uint8_t au8Alc889aAdcs[] = { 0x7, 0x8, 0x9, 0};
    379 const static uint8_t au8Alc889aSpdifOuts[] = { 0x6, 0 };
    380 const static uint8_t au8Alc889aSpdifIns[] = { 0xA, 0 };
    381 const static uint8_t au8Alc889aDigOutPins[] = { 0x1E, 0 };
    382 const static uint8_t au8Alc889aDigInPins[] = { 0x1F, 0 };
    383 const static uint8_t au8Alc889aAdcVols[] = { 0xE, 0xF, 0xD, 0xC, 0x26, 0xB, 0};
    384 const static uint8_t au8Alc889aAdcMuxs[] = { 0x22, 0x23, 0x24, 0};
    385 const static uint8_t au8Alc889aPcbeeps[] = { 0x1D, 0 };
    386 const static uint8_t au8Alc889aCds[] = { 0x1C, 0 };
    387 const static uint8_t au8Alc889aVolKnobs[] = { 0x21, 0 };
    388 const static uint8_t au8Alc889aReserveds[] = { 0x10, 0x11, 0x12, 0x13, 0 };
     382const static uint8_t au8Alc885Ports[] = { 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0};
     383const static uint8_t au8Alc885Dacs[] = { 0x2, 0x3, 0x4, 0x5, 0x25, 0};
     384const static uint8_t au8Alc885Adcs[] = { 0x7, 0x8, 0x9, 0};
     385const static uint8_t au8Alc885SpdifOuts[] = { 0x6, 0 };
     386const static uint8_t au8Alc885SpdifIns[] = { 0xA, 0 };
     387const static uint8_t au8Alc885DigOutPins[] = { 0x1E, 0 };
     388const static uint8_t au8Alc885DigInPins[] = { 0x1F, 0 };
     389const static uint8_t au8Alc885AdcVols[] = { 0xE, 0xF, 0xD, 0xC, 0x26, 0xB, 0};
     390const static uint8_t au8Alc885AdcMuxs[] = { 0x22, 0x23, 0x24, 0};
     391const static uint8_t au8Alc885Pcbeeps[] = { 0x1D, 0 };
     392const static uint8_t au8Alc885Cds[] = { 0x1C, 0 };
     393const static uint8_t au8Alc885VolKnobs[] = { 0x21, 0 };
     394const static uint8_t au8Alc885Reserveds[] = { 0x10, 0x11, 0x12, 0x13, 0 };
    389395
    390396
    … …  
    394400{
    395401    unconst(pState->cTotalNodes) = 0x27;
     402    pState->u16VendorId = 0x10ec;
     403    pState->u16DeviceId =  0x0885;
    396404    pState->pfnCodecNodeReset = alc885ResetNode;
    397405    pState->pNodes = (PCODECNODE)RTMemAllocZ(sizeof(CODECNODE) * pState->cTotalNodes);
    398406    pState->fInReset = false;
    399 #define ALC885WIDGET(type) pState->au8##type##s = au8Alc889a##type##s
     407#define ALC885WIDGET(type) pState->au8##type##s = au8Alc885##type##s
    400408    ALC885WIDGET(Port);
    401409    ALC885WIDGET(Dac);
    … …  
    435443            pNode->node.au32F00_param[5] = RT_BIT(8) | 0x1; /* UnSol: enabled, function group type: AFG */
    436444            pNode->node.au32F00_param[0xa] = 0xe0560;
    437             pNode->afg.u32F20_param = 0x10ec0889;
     445            pNode->afg.u32F20_param = pState->u16VendorId << 16 | pState->u16DeviceId;
    438446            pNode->node.au32F00_param[0xB] = 0x1;
     447            pNode->node.au32F00_param[0x11] = RT_BIT(30)|0x2;
    439448            break;
    440449        /* DACs */
    … …  
    484493            goto vendor_define_init;
    485494        case 0x11:
    486             pNode->node.name = "VENDEF-1";
     495            pNode->node.name = "VENDEF-0";
    487496            goto vendor_define_init;
    488497        case 0x12:
    … …  
    512521            break;
    513522        case 0x1F:
    514             pNode->node.name = "DIGOUT-0";
     523            pNode->node.name = "DIGIN-0";
    515524            pNode->node.au32F00_param[9] = 0x400200;
    516525            /* N = 0~3 */
    … …  
    701710            pNode->node.au32F00_param[0xD] = 0x80000000;
    702711            pNode->node.au32F00_param[0xE] = 0xb;
    703             goto adc_mux_init;
    704         case 0x24:
    705             pNode->node.name = "AdcMux-2";
    706             pNode->node.au32F00_param[0x9] = 0x20010b;
    707             pNode->node.au32F00_param[0xD] = 0x80000000;
    708             pNode->node.au32F00_param[0xE] = 0xb;
    709712        adc_mux_init:
    710713            /* N = 0~3 */
    … …  
    723726            pNode->node.au32F02_param[10] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0);
    724727            pNode->node.au32F02_param[11] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0);
     728            break;
     729        case 0x24:
     730            pNode->node.name = "AdcMux-2";
     731            pNode->node.au32F00_param[0x9] = 0x20010b;
     732            pNode->node.au32F00_param[0xD] = 0x80000000;
     733            pNode->node.au32F00_param[0xE] = 0xb;
     734            /* N = 0~3 */
     735            pNode->node.au32F02_param[0] = RT_MAKE_U32_FROM_U8(0x18, 0x19, 0x1A, 0x1B);
     736            pNode->node.au32F02_param[1] = RT_MAKE_U32_FROM_U8(0x18, 0x19, 0x1A, 0x1B);
     737            pNode->node.au32F02_param[2] = RT_MAKE_U32_FROM_U8(0x18, 0x19, 0x1A, 0x1B);
     738            pNode->node.au32F02_param[3] = RT_MAKE_U32_FROM_U8(0x18, 0x19, 0x1A, 0x1B);
     739            /* N = 4~7 */
     740            pNode->node.au32F02_param[4] = RT_MAKE_U32_FROM_U8(0x1C, 0x1D, 0x14, 0x15);
     741            pNode->node.au32F02_param[5] = RT_MAKE_U32_FROM_U8(0x1C, 0x1D, 0x14, 0x15);
     742            pNode->node.au32F02_param[6] = RT_MAKE_U32_FROM_U8(0x1C, 0x1D, 0x14, 0x15);
     743            pNode->node.au32F02_param[7] = RT_MAKE_U32_FROM_U8(0x1C, 0x1D, 0x14, 0x15);
     744            /* N = 8~11 */
     745            pNode->node.au32F02_param[8] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0x12);
     746            pNode->node.au32F02_param[9] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0x12);
     747            pNode->node.au32F02_param[10] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0x12);
     748            pNode->node.au32F02_param[11] = RT_MAKE_U32_FROM_U8(0x16, 0x17, 0xB, 0x12);
    725749            break;
    726750        /* PCBEEP */
    … …  
    9851009    else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    9861010        *pResp = pState->pNodes[CODEC_NID(cmd)].adc.u32F01_param;
     1011    else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     1012        *pResp = pState->pNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
    9871013    return VINF_SUCCESS;
    9881014}
    … …  
    10071033    else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    10081034        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].adc.u32F01_param;
     1035    else if (codecIsAdcVolNode(pState, CODEC_NID(cmd)))
     1036        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].adcvol.u32F01_param;
    10091037    Assert((pu32Reg));
    10101038    if (pu32Reg)
    … …  
    10321060    else if (codecIsCdNode(pState, CODEC_NID(cmd)))
    10331061        *pResp = pState->pNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
    1034     else if (   codecIsReservedNode(pState, CODEC_NID(cmd))
    1035              && CODEC_NID(cmd) == 0x1b)
     1062    else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1063        *pResp = pState->pNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
     1064    else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
    10361065        *pResp = pState->pNodes[CODEC_NID(cmd)].reserved.u32F07_param;
    10371066    else
    … …  
    10601089    else if (codecIsCdNode(pState, CODEC_NID(cmd)))
    10611090        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].cdnode.u32F07_param;
     1091    else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1092        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].pcbeep.u32F07_param;
    10621093    else if (   codecIsReservedNode(pState, CODEC_NID(cmd))
    1063              && CODEC_NID(cmd) == 0x1b)
     1094             && CODEC_NID(cmd) == 0x1b
     1095             && pState->enmCodec == STAC9220_CODEC)
    10641096        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].reserved.u32F07_param;
    10651097    Assert((pu32Reg));
    … …  
    10881120    else if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
    10891121        *pResp = pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     1122    else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1123        *pResp = pState->pNodes[CODEC_NID(cmd)].digout.u32F08_param;
     1124    else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1125        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
    10901126    else
    10911127        AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
    … …  
    11131149    else if (codecIsVolKnobNode(pState, CODEC_NID(cmd)))
    11141150        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     1151    else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
     1152        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
     1153    else if (codecIsDigOutPinNode(pState, CODEC_NID(cmd)))
     1154        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digout.u32F08_param;
    11151155    else
    11161156        AssertMsgFailed(("unsupported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
    … …  
    12631303}
    12641304
     1305/* F20 */
    12651306static int codecGetSubId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    12661307{
    … …  
    12781319    }
    12791320    return VINF_SUCCESS;
     1321}
     1322
     1323static int codecSetSubIdX(struct CODECState *pState, uint32_t cmd, uint8_t u8Offset)
     1324{
     1325    Assert((CODEC_CAD(cmd) == pState->id));
     1326    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1327    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1328    {
     1329        Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1330        return VINF_SUCCESS;
     1331    }
     1332    uint32_t *pu32Reg = NULL;
     1333    if (CODEC_NID(cmd) == 0x1 /* AFG */)
     1334        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].afg.u32F20_param;
     1335    Assert((pu32Reg));
     1336    if (pu32Reg)
     1337        codecSetRegisterU8(pu32Reg, cmd, u8Offset);
     1338    return VINF_SUCCESS;
     1339}
     1340/* 720 */
     1341static int codecSetSubId0 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1342{
     1343    *pResp = 0;
     1344    return codecSetSubIdX(pState, cmd, 0);
     1345}
     1346
     1347/* 721 */
     1348static int codecSetSubId1 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1349{
     1350    *pResp = 0;
     1351    return codecSetSubIdX(pState, cmd, 8);
     1352}
     1353/* 722 */
     1354static int codecSetSubId2 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1355{
     1356    *pResp = 0;
     1357    return codecSetSubIdX(pState, cmd, 16);
     1358}
     1359/* 723 */
     1360static int codecSetSubId3 (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1361{
     1362    *pResp = 0;
     1363    return codecSetSubIdX(pState, cmd, 24);
    12801364}
    12811365
    … …  
    13191403    else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    13201404        *pResp = pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
     1405    else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1406        *pResp = pState->pNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
     1407    else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1408        *pResp = pState->pNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
     1409    else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1410        *pResp = pState->pNodes[CODEC_NID(cmd)].reserved.u32F05_param;
    13211411    return VINF_SUCCESS;
    13221412}
    … …  
    13421432    else if (codecIsAdcNode(pState, CODEC_NID(cmd)))
    13431433        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
     1434    else if (codecIsSpdifOutNode(pState, CODEC_NID(cmd)))
     1435        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].spdifout.u32F05_param;
     1436    else if (codecIsSpdifInNode(pState, CODEC_NID(cmd)))
     1437        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].spdifin.u32F05_param;
     1438    else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1439        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].reserved.u32F05_param;
    13441440    Assert((pu32Reg));
    13451441    if (!pu32Reg)
    … …  
    15481644}
    15491645
     1646/* F17 */
     1647static int codecGetGPIOUnsolisted (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1648{
     1649    Assert((CODEC_CAD(cmd) == pState->id));
     1650    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1651    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1652    {
     1653        Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1654        return VINF_SUCCESS;
     1655    }
     1656    *pResp = 0;
     1657    /* note: this is true for ALC885 */
     1658    if (CODEC_NID(cmd) == 0x1 /* AFG */)
     1659        *pResp = pState->pNodes[1].afg.u32F17_param;
     1660    return VINF_SUCCESS;
     1661}
     1662
     1663/* 717 */
     1664static int codecSetGPIOUnsolisted (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     1665{
     1666    Assert((CODEC_CAD(cmd) == pState->id));
     1667    Assert((CODEC_NID(cmd) < pState->cTotalNodes));
     1668    if (CODEC_NID(cmd) >= pState->cTotalNodes)
     1669    {
     1670        Log(("HDAcodec: invalid node address %d\n", CODEC_NID(cmd)));
     1671        return VINF_SUCCESS;
     1672    }
     1673    uint32_t *pu32Reg = NULL;
     1674    *pResp = 0;
     1675    if (CODEC_NID(cmd) == 1 /* AFG */)
     1676        pu32Reg = &pState->pNodes[1].afg.u32F17_param;
     1677    Assert((pu32Reg));
     1678    if (pu32Reg)
     1679        codecSetRegisterU8(pu32Reg, cmd, 0);
     1680    return VINF_SUCCESS;
     1681}
     1682
    15501683/* F1C */
    15511684static int codecGetConfig (struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    … …  
    15651698    else if (codecIsDigInPinNode(pState, CODEC_NID(cmd)))
    15661699        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F1c_param;
     1700    else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1701        *pResp = pState->pNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
    15671702    else if (codecIsCdNode(pState, CODEC_NID(cmd)))
    15681703        *pResp = pState->pNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
     1704    else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
     1705        *pResp = pState->pNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
    15691706    return VINF_SUCCESS;
    15701707}
    … …  
    15871724    else if (codecIsCdNode(pState, CODEC_NID(cmd)))
    15881725        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].cdnode.u32F1c_param;
    1589     else if (   CODEC_NID(cmd) == 0x1B
    1590              && pState->enmCodec == STAC9220_CODEC)
     1726    else if (codecIsPcbeepNode(pState, CODEC_NID(cmd)))
     1727        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].pcbeep.u32F1c_param;
     1728    else if (codecIsReservedNode(pState, CODEC_NID(cmd)))
    15911729        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].reserved.u32F1c_param;
    15921730    Assert((pu32Reg));
    … …  
    16661804    {0x00070E00, CODEC_VERB_8BIT_CMD , codecSetDigitalConverter2   },
    16671805    {0x000F2000, CODEC_VERB_8BIT_CMD , codecGetSubId               },
     1806    {0x00072000, CODEC_VERB_8BIT_CMD , codecSetSubId0              },
     1807    {0x00072100, CODEC_VERB_8BIT_CMD , codecSetSubId1              },
     1808    {0x00072200, CODEC_VERB_8BIT_CMD , codecSetSubId2              },
     1809    {0x00072300, CODEC_VERB_8BIT_CMD , codecSetSubId3              },
    16681810    {0x0007FF00, CODEC_VERB_8BIT_CMD , codecReset                  },
    16691811    {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState          },
    … …  
    16731815    {0x000F0F00, CODEC_VERB_8BIT_CMD , codecGetVolumeKnobCtrl      },
    16741816    {0x00070F00, CODEC_VERB_8BIT_CMD , codecSetVolumeKnobCtrl      },
     1817    {0x000F1700, CODEC_VERB_8BIT_CMD , codecGetGPIOUnsolisted      },
     1818    {0x00071700, CODEC_VERB_8BIT_CMD , codecSetGPIOUnsolisted      },
    16751819    {0x000F1C00, CODEC_VERB_8BIT_CMD , codecGetConfig              },
    16761820    {0x00071C00, CODEC_VERB_8BIT_CMD , codecSetConfig0             },
    … …  
    18001944{
    18011945    SSMR3GetMem (pSSMHandle, pCodecState->pNodes, sizeof(CODECNODE) * pCodecState->cTotalNodes);
    1802     codecToAudVolume(&pCodecState->pNodes[pCodecState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
     1946    if (codecIsDacNode(pCodecState, pCodecState->u8DacLineOut))
     1947        codecToAudVolume(&pCodecState->pNodes[pCodecState->u8DacLineOut].dac.B_params, AUD_MIXER_VOLUME);
     1948    else if (codecIsSpdifOutNode(pCodecState, pCodecState->u8DacLineOut))
     1949        codecToAudVolume(&pCodecState->pNodes[pCodecState->u8DacLineOut].spdifout.B_params, AUD_MIXER_VOLUME);
    18031950    codecToAudVolume(&pCodecState->pNodes[pCodecState->u8AdcVolsLineIn].adcvol.B_params, AUD_MIXER_LINE_IN);
    18041951    return VINF_SUCCESS;

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

    r32933 r33327  
    8888{
    8989    CODECCOMMONNODE node;
     90    uint32_t    u32F05_param;
    9091    uint32_t    u32F06_param;
    9192    uint32_t    u32F09_param;
    … …  
    99100{
    100101    CODECCOMMONNODE node;
     102    uint32_t    u32F05_param;
    101103    uint32_t    u32F06_param;
    102104    uint32_t    u32F09_param;
    … …  
    113115    uint32_t  u32F08_param;
    114116    uint32_t  u32F20_param;
     117    uint32_t  u32F17_param;
    115118} AFGCODECNODE, *PAFGCODECNODE;
    116119
    … …  
    130133    CODECCOMMONNODE node;
    131134    uint32_t u32F01_param;
     135    uint32_t u32F08_param;
    132136    uint32_t u32F07_param;
    133137    uint32_t u32F09_param;
    … …  
    159163{
    160164    CODECCOMMONNODE node;
     165    uint32_t    u32F07_param;
    161166    uint32_t    u32F0a_param;
    162167
    163168    uint32_t    u32A_param;
    164169    AMPLIFIER   B_params;
     170    uint32_t u32F1c_param;
    165171} PCBEEPNODE, *PPCBEEPNODE;
    166172
    … …  
    183189    CODECCOMMONNODE node;
    184190    uint32_t    u32F0c_param;
     191    uint32_t    u32F01_param;
    185192    uint32_t    u32A_params;
    186193    AMPLIFIER   B_params;
    … …  
    190197{
    191198    CODECCOMMONNODE node;
     199    uint32_t    u32F05_param;
     200    uint32_t    u32F06_param;
    192201    uint32_t    u32F07_param;
    193     uint32_t    u32F06_param;
    194202    uint32_t    u32F1c_param;
    195203} RESNODE, *PRESNODE;
    … …  
    231239{
    232240    uint16_t                id;
     241    uint16_t                u16VendorId;
     242    uint16_t                u16DeviceId;
    233243    CODECVERB               *pVerbs;
    234244    int                     cVerbs;

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

    r33236 r33327  
    4040#define USE_MIXER
    4141#endif
     42#define VBOX_WITH_INTEL_HDA
    4243
    4344#define HDA_SSM_VERSION 1
    … …  
    653654        if (RT_FAILURE(rc))
    654655            AssertRCReturn(rc, rc);
     656#ifdef DEBUG_CMD_BUFFER
    655657        uint8_t i = 0;
    656658        do
    … …  
    673675            i += 8;
    674676        } while(i != 0);
     677#endif
    675678    }
    676679    else
    … …  
    680683        if (RT_FAILURE(rc))
    681684            AssertRCReturn(rc, rc);
     685#ifdef DEBUG_CMD_BUFFER
    682686        uint8_t i = 0;
    683687        do {
    … …  
    695699            i += 8;
    696700        } while (i != 0);
     701#endif
    697702    }
    698703    return rc;
    699704}
    700 
    701 #if 0
    702 static int hdaUnsolictedResponse(INTELHDLinkState *pState, uint64_t pu64UnsolictedResponse)
    703 {
    704     uint8_t rirbWp;
    705     if (!HDA_REG_FLAG_VALUE(pState, GCTL, UR))
    706     {
    707         Log(("hda: unsolicited response %016lx is ignored\n"));
    708         return VINF_SUCCESS;
    709     }
    710 }
    711 #endif
    712705
    713706static int hdaCORBCmdProcess(INTELHDLinkState *pState)
    … …  
    13461339            pBdle->u32BdleCvi++;
    13471340            if (pBdle->u32BdleCvi == pBdle->u32BdleMaxCvi + 1)
     1341            {
    13481342                pBdle->u32BdleCvi = 0;
     1343            }
    13491344            fStop = true;   /* Give the guest a chance to refill (or empty) buffers. */
    1350 
    1351             /* Read the next BDE unless we're exiting. */
    1352             if (!fStop)
    1353                 fetch_bd(pState, pBdle, u64BaseDMA);
    13541345        }
    13551346    }
    … …  
    16631654
    16641655    /* PCI Device (the assertions will be removed later) */
    1665 #if 1
     1656#if defined(VBOX_WITH_HP_HDA)
     1657    /* Linux kernel has whitelist for MSI-enabled HDA, this card seems to be there. */
     1658    PCIDevSetVendorId           (&pThis->dev, 0x103c); /* HP. */
     1659    PCIDevSetDeviceId           (&pThis->dev, 0x30f7); /* HP Pavilion dv4t-1300 */
     1660#elif defined(VBOX_WITH_INTEL_HDA)
    16661661    PCIDevSetVendorId           (&pThis->dev, 0x8086); /* 00 ro - intel. */
    16671662    PCIDevSetDeviceId           (&pThis->dev, 0x2668); /* 02 ro - 82801 / 82801aa(?). */
     1663#elif defined(VBOX_WITH_NVIDIA_HDA)
     1664    PCIDevSetVendorId           (&pThis->dev, 0x10de); /* nVidia */
     1665    PCIDevSetDeviceId           (&pThis->dev, 0x0ac0); /* HDA */
    16681666#else
    1669     PCIDevSetVendorId           (&pThis->dev, 0x10de); /* nVidia */
    1670     PCIDevSetDeviceId           (&pThis->dev, 0x0028); /* HDA */
     1667# error "Please specify your HDA device vendor/device IDs"
    16711668#endif
    16721669    PCIDevSetCommand            (&pThis->dev, 0x0000); /* 04 rw,ro - pcicmd. */
    … …  
    16791676    PCIDevSetBaseAddress        (&pThis->dev, 0,       /* 10 rw - MMIO */
    16801677                                 false /* fIoSpace */, false /* fPrefetchable */, true /* f64Bit */, 0x00000000);
    1681     /* ICH6 datasheet defines 0 values for SVID and SID (18.1.14-15), which together with values returned for
    1682        verb F20 should provide device/codec recognition. */
    1683     PCIDevSetSubSystemVendorId  (&pThis->dev, 0x0000); /* 2c ro - intel.) */
    1684     PCIDevSetSubSystemId        (&pThis->dev, 0x0000); /* 2e ro. */
    16851678    PCIDevSetInterruptLine      (&pThis->dev, 0x00);   /* 3c rw. */
    16861679    PCIDevSetInterruptPin       (&pThis->dev, 0x01);   /* 3d ro - INTA#. */
    … …  
    17961789
    17971790    pThis->hda.Codec.pHDAState = (void *)&pThis->hda;
    1798     rc = codecConstruct(&pThis->hda.Codec, STAC9220_CODEC);
     1791    rc = codecConstruct(&pThis->hda.Codec, /* ALC885_CODEC */ STAC9220_CODEC);
    17991792    if (RT_FAILURE(rc))
    18001793        AssertRCReturn(rc, rc);
     1794
     1795    /* ICH6 datasheet defines 0 values for SVID and SID (18.1.14-15), which together with values returned for
     1796       verb F20 should provide device/codec recognition. */
     1797    Assert(pThis->hda.Codec.u16VendorId);
     1798    Assert(pThis->hda.Codec.u16DeviceId);
     1799    PCIDevSetSubSystemVendorId  (&pThis->dev, pThis->hda.Codec.u16VendorId); /* 2c ro - intel.) */
     1800    PCIDevSetSubSystemId        (&pThis->dev, pThis->hda.Codec.u16DeviceId); /* 2e ro. */
     1801
    18011802    hdaReset (pDevIns);
    18021803    pThis->hda.Codec.id = 0;
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