VirtualBox

Changeset 31156 in vbox


Ignore:
Timestamp:
Jul 28, 2010 2:49:45 AM (14 years ago)
Author:
vboxsync
Message:

Audio/HDA: HDA: 1. UR delivered depending on GCTL status, 2. MSI removed from PCI capabilities list.

Codec: 1. UR enabled (verbID F08/708), 2. Power States F00:0F reports support of D0 and D3, 3. VerbID F05/705 are added, 4. Pin Sence (F09/709).

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

Legend:

Unmodified
Added
Removed

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

    r31084 r31156  
    5959#define CODEC_B_INDEX(cmd)      ((cmd) & CODEC_VERB_B_INDEX)
    6060
    61 /* RPM 5.3.1 */
    62 #define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
    6361
    6462#define STAC9220_NODE_COUNT 0x1C
    … …  
    10199#define STAC9220_IS_CD_CMD(cmd) (CODEC_NID((cmd)) == 0x15)
    102100
     101#define STAC9220_IS_VOLKNOB_CMD(cmd) (CODEC_NID((cmd)) == 0x15)
     102
    103103/* STAC9220 6.2 & 6.12 */
    104104#define STAC9220_IS_RESERVED_CMD(cmd) ( \
    … …  
    123123    int rc;
    124124    rc = codecUnimplemented(pState, cmd, pResp);
    125     *pResp |= CODEC_RESPONSE_UNSOLICITED;
     125    *pResp |= CODEC_RESPONSE_UNSOLICITED; /* ??? */
    126126    return rc;
    127127}
    … …  
    218218    return VINF_SUCCESS;
    219219}
     220
     221static int codecGetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     222{
     223    *pResp = 0;
     224    if (STAC9220_IS_PORT_CMD(cmd))
     225        *pResp = pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
     226    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     227        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
     228    else if (STAC9220_IS_AFG_CMD(cmd))
     229        *pResp = pState->pNodes[CODEC_NID(cmd)].afg.u32F08_param;
     230    else if (STAC9220_IS_VOLKNOB_CMD(cmd))
     231        *pResp = pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     232    else
     233        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
     234    return VINF_SUCCESS;
     235}
     236
     237static int codecSetUnsolicitedEnabled(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     238{
     239    *pResp = 0;
     240    uint32_t *pu32Reg = NULL;
     241    if (STAC9220_IS_PORT_CMD(cmd))
     242        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
     243    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     244        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
     245    else if (STAC9220_IS_AFG_CMD(cmd))
     246        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].afg.u32F08_param;
     247    else if (STAC9220_IS_VOLKNOB_CMD(cmd))
     248        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].volumeKnob.u32F08_param;
     249    else
     250        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
     251    Assert(pu32Reg);
     252    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
     253    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
     254    return VINF_SUCCESS;
     255}
     256
     257static int codecGetPinSence(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     258{
     259    *pResp = 0;
     260    if (STAC9220_IS_PORT_CMD(cmd))
     261        *pResp = pState->pNodes[CODEC_NID(cmd)].port.u32F09_param;
     262    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     263        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F09_param;
     264    else
     265        AssertMsgFailed(("unsuported operation %x on node: %x\n", CODEC_VERB_CMD8(cmd), CODEC_NID(cmd)));
     266    return VINF_SUCCESS;
     267}
     268static int codecSetPinSence(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     269{
     270    *pResp = 0;
     271    uint32_t *pu32Reg = NULL;
     272    if (STAC9220_IS_PORT_CMD(cmd))
     273        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].port.u32F08_param;
     274    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     275        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F08_param;
     276    Assert(pu32Reg);
     277    if(!pu32Reg)
     278        return VINF_SUCCESS;
     279    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
     280    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
     281    return VINF_SUCCESS;
     282}
     283
    220284static int codecGetConnectionListEntry(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    221285{
    … …  
    308372}
    309373
    310 #if 0
    311374static int codecGetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    312375{
    313376    Assert((CODEC_CAD(cmd) == pState->id));
     377    *pResp = 0;
    314378    if (STAC9220_IS_AFG_CMD(cmd))
    315379    {
    316380        *pResp = pState->pNodes[CODEC_NID(cmd)].afg.u32F05_param;
    317381    }
    318     return VINF_SUCCESS;
    319 }
    320 #endif
     382    else if (STAC9220_IS_DAC_CMD(cmd))
     383    {
     384        *pResp = pState->pNodes[CODEC_NID(cmd)].dac.u32F05_param;
     385    }
     386    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     387    {
     388        *pResp = pState->pNodes[CODEC_NID(cmd)].digin.u32F05_param;
     389    }
     390    else if (STAC9220_IS_ADC_CMD(cmd))
     391    {
     392        *pResp = pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
     393    }
     394    return VINF_SUCCESS;
     395}
     396
     397static int codecSetPowerState(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
     398{
     399    Assert((CODEC_CAD(cmd) == pState->id));
     400    uint32_t *pu32Reg = NULL;
     401    *pResp = 0;
     402    if (STAC9220_IS_AFG_CMD(cmd))
     403    {
     404        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].afg.u32F05_param;
     405    }
     406    else if (STAC9220_IS_DAC_CMD(cmd))
     407    {
     408        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].dac.u32F05_param;
     409    }
     410    else if (STAC9220_IS_DIGPIN_CMD(cmd))
     411    {
     412        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].digin.u32F05_param;
     413    }
     414    else if (STAC9220_IS_ADC_CMD(cmd))
     415    {
     416        pu32Reg = &pState->pNodes[CODEC_NID(cmd)].adc.u32F05_param;
     417    }
     418    Assert((pu32Reg));
     419    if (!pu32Reg)
     420        return VINF_SUCCESS;
     421    *pu32Reg &= ~CODEC_VERB_8BIT_DATA;
     422    *pu32Reg |= cmd & CODEC_VERB_8BIT_DATA;
     423    return VINF_SUCCESS;
     424}
     425
    321426static int codecGetStreamId(struct CODECState *pState, uint32_t cmd, uint64_t *pResp)
    322427{
    … …  
    387492{
    388493    pNode->node.id = nodenum;
     494    pNode->node.au32F00_param[0xF] = RT_BIT(3)|RT_BIT(0); /* Power statest Supported: D0-yes, D1, D2, D3-no*/
    389495    switch (nodenum)
    390496    {
    … …  
    401507            pNode->afg.node.name = "AFG";
    402508            pNode->node.au32F00_param[4] = RT_MAKE_U32_FROM_U8(0x1a, 0x00, 0x02, 0x00);
    403             pNode->node.au32F00_param[5] = RT_MAKE_U32_FROM_U8(0x1, 0x01, 0x00, 0x0);
     509            pNode->node.au32F00_param[5] = RT_BIT(8)|RT_BIT(0);
    404510            pNode->node.au32F00_param[8] = RT_MAKE_U32_FROM_U8(0x0d, 0x0d, 0x01, 0x0); /* Capabilities */
    405511            //pNode->node.au32F00_param[0xa] = RT_BIT(19)|RT_BIT(18)|RT_BIT(17)|RT_BIT(10)|RT_BIT(9)|RT_BIT(8)|RT_BIT(7)|RT_BIT(6)|RT_BIT(5);
    406512            pNode->node.au32F00_param[0xa] = RT_BIT(17)|RT_BIT(5);
     513            pNode->node.au32F00_param[0xc] = (17 << 8)|RT_BIT(6)|RT_BIT(5)|RT_BIT(2)|RT_BIT(1)|RT_BIT(0);
    407514            pNode->node.au32F00_param[0xb] = RT_BIT(0);
    408515            pNode->node.au32F00_param[0xd] = RT_BIT(31)|(0x5 << 16)|(0xE)<<8;
    409516            pNode->node.au32F00_param[0x12] = RT_BIT(31)|(0x2 << 16)|(0x7f << 8)|0x7f;
    410             pNode->afg.u32F05_param = (0x2) << 4 | 0x2; /* PS-Act: 0x2, D2 */
    411             pNode->afg.u32F20_param = 0x83847626; /*STAC9271X */
    412             pNode->afg.u32F08_param = 0;
     517            pNode->node.au32F00_param[0x11] = 0;
     518            pNode->afg.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
     519            pNode->afg.u32F20_param = 0x83847882;
     520            pNode->afg.u32F08_param = RT_BIT(7);
    413521            break;
    414522        case 2:
    … …  
    433541            pNode->dac.node.au32F00_param[5] = (0x3 << 4) | 0x3;
    434542            pNode->dac.u32F0c_param = 0;
     543            pNode->dac.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
    435544        break;
    436545        case 6:
    … …  
    445554            pNode->adc.node.au32F00_param[0xE] = RT_BIT(0);
    446555            pNode->adc.u32F03_param = RT_BIT(0);
    447             pNode->adc.u32F05_param = (0x3 << 4) | 0x3;
     556            pNode->adc.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
    448557            pNode->adc.u32F06_param = 0;
    449558            pNode->adc.node.au32F00_param[9] = RT_BIT(20)| (0xd << 16) |  RT_BIT(10) | RT_BIT(8) | RT_BIT(6)| RT_BIT(0);
    … …  
    464573        case 0xA:
    465574            pNode->node.name = "PortA";
    466             pNode->node.au32F00_param[0xC] = 0x173f;
     575            pNode->node.au32F00_param[0xC] = 0x173d;
    467576            *(uint32_t *)pNode->node.au8F02_param = 0x2;
    468             pNode->port.u32F07_param = 0;
     577            pNode->port.u32F07_param = RT_BIT(6);
     578            pNode->port.u32F08_param = RT_BIT(7);
     579            pNode->port.u32F09_param = RT_BIT(31)|RT_BIT(30); /* 39.2 kOm */
    469580            pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x20, 0x40, 0x21, 0x02);
    470581            goto port_init;
    … …  
    473584            pNode->node.au32F00_param[0xC] = 0x1737;
    474585            *(uint32_t *)pNode->node.au8F02_param = 0x4;
     586            pNode->port.u32F09_param = 0;
    475587            pNode->port.u32F07_param = RT_BIT(5);
    476588            pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x11, 0x60, 0x11, 0x01);
    … …  
    480592            *(uint32_t *)pNode->node.au8F02_param = 0x3;
    481593            pNode->node.au32F00_param[0xC] = 0x1737;
     594            pNode->port.u32F09_param = 0;
    482595            pNode->port.u32F07_param = RT_BIT(5);
    483596            pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x10, 0x40, 0x11, 0x01);
    … …  
    485598        case 0xD:
    486599            pNode->node.name = "PortD";
     600            pNode->port.u32F09_param = 0;
    487601            *(uint32_t *)pNode->node.au8F02_param = 0x2;
    488602        port_init:
    489603            pNode->port.u32F08_param = 0;
    490             pNode->port.u32F09_param = 0x7fffffff;
    491604            pNode->node.au32F00_param[9] = (4 << 20)|RT_BIT(8)|RT_BIT(7)|RT_BIT(0);
    492605            pNode->node.au32F00_param[0xE] = 0x1;
    … …  
    510623            pNode->port.u32F1c_param = RT_MAKE_U32_FROM_U8(0x12, 0x60, 0x11, 0x01);
    511624            pNode->node.au8F02_param[0] = 0x5;
    512             pNode->port.u32F09_param = 0x7fffffff;
     625            pNode->port.u32F09_param = 0;
    513626        break;
    514627        case 0x10:
    … …  
    526639            pNode->node.au32F00_param[9] = (4 << 20)|(3<<16)|RT_BIT(10)|RT_BIT(9)|RT_BIT(7)|RT_BIT(0);
    527640            pNode->node.au32F00_param[0xC] = /* RT_BIT(16)|*/ RT_BIT(5)|RT_BIT(2);
    528             pNode->digin.u32F05_param = (3 << 4)|0x3;
     641            pNode->digin.u32F05_param = 0x3 << 4; /* PS-Act: D3 -> D0 */
    529642            pNode->digin.u32F07_param = 0;
    530643            pNode->digin.u32F08_param = 0;
    … …  
    606719    {0x000F0700, CODEC_VERB_8BIT_CMD , codecGetPinCtrl             },
    607720    {0x00070700, CODEC_VERB_8BIT_CMD , codecSetPinCtrl             },
     721    {0x000F0800, CODEC_VERB_8BIT_CMD , codecGetUnsolicitedEnabled  },
     722    {0x00070800, CODEC_VERB_8BIT_CMD , codecSetUnsolicitedEnabled  },
     723    {0x000F0900, CODEC_VERB_8BIT_CMD , codecGetPinSence            },
     724    {0x00070900, CODEC_VERB_8BIT_CMD , codecSetPinSence            },
    608725    {0x000F0200, CODEC_VERB_8BIT_CMD , codecGetConnectionListEntry },
    609726    {0x000F0300, CODEC_VERB_8BIT_CMD , codecGetProcessingState     },
    … …  
    614731    {0x000F2000, CODEC_VERB_8BIT_CMD , codecGetSubId               },
    615732    {0x0007FF00, CODEC_VERB_8BIT_CMD , codecReset                  },
    616 #if 0
    617     {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState},
    618 #endif
     733    {0x000F0500, CODEC_VERB_8BIT_CMD , codecGetPowerState          },
     734    {0x00070500, CODEC_VERB_8BIT_CMD , codecSetPowerState          },
    619735};
    620736
    … …  
    627743        || STAC9220_IS_RESERVED_CMD(cmd))
    628744    {
    629         *pfn = CODEC_VERBDATA(cmd) != 0 ? codecUnimplemented : codecBreak;
     745        *pfn = codecUnimplemented;
    630746        //** @todo r=michaln: There needs to be a counter to avoid log flooding (see e.g. DevRTC.cpp)
    631747        LogRel(("HDAcodec: cmd %x was ignored\n", cmd));

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

    r31062 r31156  
    2323typedef FNCODECVERBPROCESSOR *PFNCODECVERBPROCESSOR;
    2424typedef FNCODECVERBPROCESSOR **PPFNCODECVERBPROCESSOR;
     25
     26/* RPM 5.3.1 */
     27#define CODEC_RESPONSE_UNSOLICITED RT_BIT_64(34)
    2528
    2629typedef struct CODECVERB

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

    r31085 r31156  
    7676#define ICH6_HDA_GCTL_RST_SHIFT (0)
    7777#define ICH6_HDA_GCTL_FSH_SHIFT (1)
     78#define ICH6_HDA_GCTL_UR_SHIFT (8)
    7879#define GCTL(pState) (HDA_REG((pState), GCTL))
    7980
    … …  
    379380    bool        fInReset;
    380381    CODECState  Codec;
     382    uint8_t     u8Counter;
    381383} INTELHDLinkState;
    382384
    … …  
    660662                else
    661663                    prefix = "   ";
    662                 Log((" %s%016x", prefix, pState->pu64RirbBuf[i + j]));
     664                Log((" %s%016lx", prefix, pState->pu64RirbBuf[i + j]));
    663665            } while (++j < 8);
    664666            Log(("\n"));
    … …  
    668670    return rc;
    669671}
     672
     673#if 0
     674static int hdaUnsolictedResponse(INTELHDLinkState *pState, uint64_t pu64UnsolictedResponse)
     675{
     676    uint8_t rirbWp;
     677    if (!HDA_REG_FLAG_VALUE(pState, GCTL, UR))
     678    {
     679        Log(("hda: unsolisited response %016lx is ignored\n"));
     680        return VINF_SUCCESS;
     681    }
     682}
     683#endif
     684
    670685static int hdaCORBCmdProcess(INTELHDLinkState *pState)
    671686{
    … …  
    674689    uint8_t corbWp;
    675690    uint8_t rirbWp;
    676     uint8_t u8Counter = 0;
    677691
    678692    PFNCODECVERBPROCESSOR pfn = (PFNCODECVERBPROCESSOR)NULL;
    … …  
    689703    {
    690704        uint32_t cmd;
     705        uint64_t resp;
    691706        corbRp++;
    692707        cmd = pState->pu32CorbBuf[corbRp];
    … …  
    696711        Assert(pfn);
    697712        (rirbWp)++;
    698         rc = pfn(&pState->Codec, cmd, &pState->pu64RirbBuf[rirbWp]);
     713        rc = pfn(&pState->Codec, cmd, &resp);
    699714        if (RT_FAILURE(rc))
    700715            AssertRCReturn(rc, rc);
    701         u8Counter++;
    702         if (u8Counter == RINTCNT_N(pState))
     716        Log(("hda: verb:%08x->%016lx\n", cmd, resp));
     717        if (   (resp & CODEC_RESPONSE_UNSOLICITED)
     718            && !HDA_REG_FLAG_VALUE(pState, GCTL, UR))
     719        {
     720            Log(("hda: unexpected unsolisited response.\n"));
     721            pState->au32Regs[ICH6_HDA_REG_CORBRP] = corbRp;
     722            return rc;
     723        }
     724        pState->pu64RirbBuf[rirbWp] = resp;
     725        pState->u8Counter++;
     726        if (pState->u8Counter == RINTCNT_N(pState))
    703727            break;
    704728    }
    … …  
    710734    {
    711735        RIRBSTS((pState)) |= HDA_REG_FIELD_FLAG_MASK(RIRBSTS,RINTFL);
     736        pState->u8Counter = 0;
    712737        rc = hdaProcessInterrupt(pState);
    713738    }
    … …  
    11661191    return VINF_SUCCESS;
    11671192}
     1193
    11681194DECLCALLBACK(void) hdaTransfer(CODECState *pCodecState, ENMSOUNDSOURCE src, int avail)
    11691195{
    … …  
    15011527    pThis->dev.config[0x53] = 0x00; /* PM - disabled,  */
    15021528
     1529#if 0
    15031530    pThis->dev.config[0x60] = 0x05;
    15041531    pThis->dev.config[0x61] = 0x70; /* next */
    15051532    pThis->dev.config[0x62] = 0x00;
    15061533    pThis->dev.config[0x63] = 0x80;
     1534#endif
    15071535
    15081536    /*
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