VirtualBox

Changeset 67241 in vbox for trunk


Ignore:
Timestamp:
Jun 2, 2017 2:32:34 PM (8 years ago)
Author:
vboxsync
Message:

HDA: Die macros die! Note: This commit is not intended to make any functional changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r67238 r67241  
    135135#define HDA_REG_IND_NAME(x)                 HDA_REG_##x
    136136#define HDA_MEM_IND_NAME(x)                 HDA_RMX_##x
    137 #define HDA_REG_FIELD_MASK(reg, x)          HDA_##reg##_##x##_MASK
    138 #define HDA_REG_FIELD_FLAG_MASK(reg, x)     RT_BIT(HDA_##reg##_##x##_SHIFT)
    139 #define HDA_REG_FIELD_SHIFT(reg, x)         HDA_##reg##_##x##_SHIFT
    140137#define HDA_REG_IND(pThis, x)               ((pThis)->au32Regs[g_aHdaRegMap[x].mem_idx])
    141138#define HDA_REG(pThis, x)                   (HDA_REG_IND((pThis), HDA_REG_IND_NAME(x)))
    142 #define HDA_REG_FLAG_VALUE(pThis, reg, val) (HDA_REG((pThis),reg) & (((HDA_REG_FIELD_FLAG_MASK(reg, val)))))
    143139
    144140
    … …  
    173169#define HDA_REG_GCTL                5 /* 0x08-0x0B */
    174170#define HDA_RMX_GCTL                5
    175 #define HDA_GCTL_RST_SHIFT          0
    176 #define HDA_GCTL_FSH_SHIFT          1
    177 #define HDA_GCTL_UR_SHIFT           8
     171#define HDA_GCTL_UNSOL              RT_BIT(8)   /* Accept Unsolicited Response Enable */
     172#define HDA_GCTL_FCNTRL             RT_BIT(1)   /* Flush Control */
     173#define HDA_GCTL_CRST               RT_BIT(0)   /* Controller Reset */
    178174
    179175#define HDA_REG_WAKEEN              6 /* 0x0C */
    … …  
    186182#define HDA_REG_GSTS                8 /* 0x10-0x11*/
    187183#define HDA_RMX_GSTS                8
    188 #define HDA_GSTS_FSH_SHIFT          1
     184#define HDA_GSTS_FSTS               RT_BIT(1)   /* Flush Status */
    189185
    190186#define HDA_REG_OUTSTRMPAY          9  /* 0x18 */
    … …  
    196192#define HDA_REG_INTCTL              11 /* 0x20 */
    197193#define HDA_RMX_INTCTL              9
    198 #define HDA_INTCTL_GIE_SHIFT        31
    199 #define HDA_INTCTL_CIE_SHIFT        30
     194#define HDA_INTCTL_GIE              RT_BIT(31)  /* Global Interrupt Enable */
     195#define HDA_INTCTL_CIE              RT_BIT(30)  /* Controller Interrupt Enable */
    200196/* Bits 0-29 correspond to streams 0-29. */
    201 #define HDA_INTCTL_GIE_MASK         RT_BIT(31) /* Global Interrupt Enable (3.3.14). */
    202197
    203198#define HDA_REG_INTSTS              12 /* 0x24 */
    204199#define HDA_RMX_INTSTS              10
    205 #define HDA_INTSTS_GIS_SHIFT        31
    206 #define HDA_INTSTS_CIS_SHIFT        30
     200#define HDA_INTSTS_GIS              RT_BIT(31)  /* Global Interrupt Status */
     201#define HDA_INTSTS_CIS              RT_BIT(30)  /* Controller Interrupt Status */
    207202/* Bits 0-29 correspond to streams 0-29. */
    208203
    … …  
    228223#define HDA_REG_CORBRP              18 /* 0x4A */
    229224#define HDA_RMX_CORBRP              16
    230 #define HDA_CORBRP_RST_SHIFT        15
     225#define HDA_CORBRP_RST              RT_BIT(15)  /* CORB Read Pointer Reset */
    231226#define HDA_CORBRP_WP_SHIFT         0
    232227#define HDA_CORBRP_WP_MASK          0xFF
    … …  
    234229#define HDA_REG_CORBCTL             19 /* 0x4C */
    235230#define HDA_RMX_CORBCTL             17
    236 #define HDA_CORBCTL_DMA_SHIFT       1
    237 #define HDA_CORBCTL_CMEIE_SHIFT     0
     231#define HDA_CORBCTL_DMA             RT_BIT(1)   /* Enable CORB DMA Engine */
     232#define HDA_CORBCTL_CMEIE           RT_BIT(0)   /* CORB Memory Error Interrupt Enable */
    238233
    239234#define HDA_REG_CORBSTS             20 /* 0x4D */
    … …  
    255250#define HDA_REG_RIRBWP              24 /* 0x58 */
    256251#define HDA_RMX_RIRBWP              22
    257 #define HDA_RIRBWP_RST_SHIFT        15
     252#define HDA_RIRBWP_RST              RT_BIT(15)  /* RIRB Write Pointer Reset */
    258253#define HDA_RIRBWP_WP_MASK          0xFF
    259254
    … …  
    264259#define HDA_REG_RIRBCTL             26 /* 0x5C */
    265260#define HDA_RMX_RIRBCTL             24
    266 #define HDA_RIRBCTL_RIC_SHIFT       0
    267 #define HDA_RIRBCTL_DMA_SHIFT       1
    268 #define HDA_ROI_DMA_SHIFT           2
     261#define HDA_RIRBCTL_ROIC            RT_BIT(2)   /* Response Overrun Interrupt Control */
     262#define HDA_RIRBCTL_RDMAEN          RT_BIT(1)   /* RIRB DMA Enable */
     263#define HDA_RIRBCTL_RINTCTL         RT_BIT(0)   /* Response Interrupt Control */
    269264
    270265#define HDA_REG_RIRBSTS             27 /* 0x5D */
    271266#define HDA_RMX_RIRBSTS             25
    272 #define HDA_RIRBSTS_RINTFL_SHIFT    0
    273 #define HDA_RIRBSTS_RIRBOIS_SHIFT   2
     267#define HDA_RIRBSTS_RIRBOIS         RT_BIT(2)   /* Response Overrun Interrupt Status */
     268#define HDA_RIRBSTS_RINTFL          RT_BIT(0)   /* Response Interrupt Flag */
    274269
    275270#define HDA_REG_RIRBSIZE            28 /* 0x5E */
    … …  
    290285#define HDA_REG_IRS                 31 /* 0x68 */
    291286#define HDA_RMX_IRS                 29
    292 #define HDA_IRS_ICB_SHIFT           0
    293 #define HDA_IRS_IRV_SHIFT           1
     287#define HDA_IRS_IRV                 RT_BIT(1)   /* Immediate Result Valid */
     288#define HDA_IRS_ICB                 RT_BIT(0)   /* Immediate Command Busy */
    294289
    295290#define HDA_REG_DPLBASE             32 /* 0x70 */
    … …  
    332327
    333328#define HDA_SDCTL(pThis, num)       HDA_REG((pThis), SD(CTL, num))
    334 #define HDA_SDCTL_NUM(pThis, num)   ((HDA_SDCTL((pThis), num) & HDA_REG_FIELD_MASK(SDCTL,NUM)) >> HDA_REG_FIELD_SHIFT(SDCTL, NUM))
    335329#define HDA_SDCTL_NUM_MASK          0xF
    336330#define HDA_SDCTL_NUM_SHIFT         20
    337 #define HDA_SDCTL_DIR_SHIFT         19
    338 #define HDA_SDCTL_TP_SHIFT          18
     331#define HDA_SDCTL_DIR               RT_BIT(19)  /* Direction (Bidirectional streams only!) */
     332#define HDA_SDCTL_TP                RT_BIT(18)  /* Traffic Priority (PCI Express) */
    339333#define HDA_SDCTL_STRIPE_MASK       0x3
    340334#define HDA_SDCTL_STRIPE_SHIFT      16
    341 #define HDA_SDCTL_DEIE_SHIFT        4
    342 #define HDA_SDCTL_FEIE_SHIFT        3
    343 #define HDA_SDCTL_ICE_SHIFT         2
    344 #define HDA_SDCTL_RUN_SHIFT         1
    345 #define HDA_SDCTL_SRST_SHIFT        0
     335#define HDA_SDCTL_DEIE              RT_BIT(4)   /* Descriptor Error Interrupt Enable */
     336#define HDA_SDCTL_FEIE              RT_BIT(3)   /* FIFO Error Interrupt Enable */
     337#define HDA_SDCTL_IOCE              RT_BIT(2)   /* Interrupt On Completion Enable */
     338#define HDA_SDCTL_RUN               RT_BIT(1)   /* Stream Run */
     339#define HDA_SDCTL_SRST              RT_BIT(0)   /* Stream Reset */
    346340
    347341#define HDA_REG_SD0STS              35 /* 0x83 */
    … …  
    497491
    498492#define SDFMT(pThis, num)               (HDA_REG((pThis), SD(FMT, num)))
    499 #define HDA_SDFMT_BASE_RATE(pThis, num) ((SDFMT(pThis, num)   & HDA_REG_FIELD_FLAG_MASK(SDFMT, BASE_RATE)) >> HDA_REG_FIELD_SHIFT(SDFMT, BASE_RATE))
    500 #define HDA_SDFMT_MULT(pThis, num)      ((SDFMT((pThis), num) & HDA_REG_FIELD_MASK(SDFMT,MULT)) >> HDA_REG_FIELD_SHIFT(SDFMT, MULT))
    501 #define HDA_SDFMT_DIV(pThis, num)       ((SDFMT((pThis), num) & HDA_REG_FIELD_MASK(SDFMT,DIV)) >> HDA_REG_FIELD_SHIFT(SDFMT, DIV))
    502493
    503494#define HDA_REG_SD0BDPL             42 /* 0x98 */
    … …  
    14381429    uint32_t intSts = 0;
    14391430
    1440     if (/* Response Overrun Interrupt Status (ROIS) */
    1441            HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RIRBOIS)
     1431    /** @todo r=michaln This is ignoring HDA_RIRBCTL_ROIC! */
     1432    if (/* Response Overrun Interrupt Status (ROIS aka RIRBOIS) */
     1433           (HDA_REG(pThis, RIRBSTS) & HDA_RIRBSTS_RIRBOIS)
    14421434        /* Response Interrupt */
    1443         || HDA_REG_FLAG_VALUE(pThis, RIRBSTS, RINTFL)
     1435        || (HDA_REG(pThis, RIRBSTS) & HDA_RIRBSTS_RINTFL)
    14441436        /* SDIN State Change Status Flags (SCSF) */
    14451437        || (HDA_REG(pThis, STATESTS) & HDA_STATESTS_SCSF_MASK))
    14461438    {
    1447         intSts |= RT_BIT(30); /* Touch Controller Interrupt Status (CIS). */
     1439        intSts |= HDA_INTSTS_CIS;   /* Set the Controller Interrupt Status (CIS). */
    14481440    }
    14491441
    … …  
    14691461
    14701462    if (intSts)
    1471         intSts |= RT_BIT(31); /* Touch Global Interrupt Status (GIS). */
     1463        intSts |= HDA_INTSTS_GIS;   /* Set the Global Interrupt Status (GIS). */
    14721464
    14731465    HDA_REG(pThis, INTSTS) = intSts;
    … …  
    14821474    int iLevel = 0;
    14831475
    1484     /* Global Interrupt Status (GIS) touched? */
    1485     if (HDA_REG_FLAG_VALUE(pThis, INTSTS, GIS))
     1476    /* Global Interrupt Status (GIS) set? */
     1477    if (HDA_REG(pThis, INTSTS) & HDA_INTSTS_GIS)
    14861478        iLevel = 1;
    14871479
    … …  
    14891481
    14901482    /* Global Interrupt Enable (GIE) set? */
    1491     if (HDA_REG_FLAG_VALUE(pThis, INTCTL, GIE))
     1483    if (HDA_REG(pThis, INTCTL) & HDA_INTCTL_GIE)
    14921484        PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0, iLevel);
    14931485
    … …  
    16071599    if (fLocal)
    16081600    {
    1609         Assert((HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA)));
     1601        Assert((HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA));
    16101602        Assert(pThis->u64CORBBase);
    16111603        AssertPtr(pThis->pu32CorbBuf);
    … …  
    16401632    else
    16411633    {
    1642         Assert((HDA_REG_FLAG_VALUE(pThis, RIRBCTL, DMA)));
     1634        Assert((HDA_REG(pThis, RIRBCTL) & HDA_RIRBCTL_RDMAEN));
    16431635        rc = PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), pThis->u64RIRBBase, pThis->pu64RirbBuf, pThis->cbRirbBuf);
    16441636        if (RT_FAILURE(rc))
    … …  
    16901682
    16911683        if (   (uResp & CODEC_RESPONSE_UNSOLICITED)
    1692             && !HDA_REG_FLAG_VALUE(pThis, GCTL, UR))
     1684            && !(HDA_REG(pThis, GCTL) & HDA_GCTL_UNSOL))
    16931685        {
    16941686            LogFunc(("Unexpected unsolicited response\n"));
    … …  
    17111703    Log3Func(("CORB(RP:%x, WP:%x) RIRBWP:%x\n", HDA_REG(pThis, CORBRP), HDA_REG(pThis, CORBWP), HDA_REG(pThis, RIRBWP)));
    17121704
    1713     if (HDA_REG_FLAG_VALUE(pThis, RIRBCTL, RIC))
    1714     {
    1715         HDA_REG(pThis, RIRBSTS) |= HDA_REG_FIELD_FLAG_MASK(RIRBSTS,RINTFL);
     1705    if (HDA_REG(pThis, RIRBCTL) & HDA_RIRBCTL_RINTCTL)
     1706    {
     1707        HDA_REG(pThis, RIRBSTS) |= HDA_RIRBSTS_RINTFL;
    17161708
    17171709        pThis->u8RespIntCnt = 0;
    … …  
    18231815
    18241816# ifdef VBOX_STRICT
    1825     AssertReleaseMsg(!RT_BOOL(HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
     1817    AssertReleaseMsg(!RT_BOOL(HDA_STREAM_REG(pThis, CTL, uSD) & HDA_SDCTL_RUN),
    18261818                     ("[SD%RU8] Cannot reset stream while in running state\n", uSD));
    18271819# endif
    … …  
    18441836    /* According to the ICH6 datasheet, 0x40000 is the default value for stream descriptor register 23:20
    18451837     * bits are reserved for stream number 18.2.33, resets SDnCTL except SRST bit. */
    1846     HDA_STREAM_REG(pThis, CTL,   uSD) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
     1838    HDA_STREAM_REG(pThis, CTL,   uSD) = 0x40000 | (HDA_STREAM_REG(pThis, CTL, uSD) & HDA_SDCTL_SRST);
    18471839    /*
    18481840     * ICH6 defines default values (120 bytes for input and 192 bytes for output descriptors) of FIFO size. 18.2.39.
    … …  
    21262118    RT_NOREF_PV(iReg);
    21272119
    2128     if (u32Value & HDA_REG_FIELD_FLAG_MASK(GCTL, RST))
     2120    if (u32Value & HDA_GCTL_CRST)
    21292121    {
    21302122        /* Set the CRST bit to indicate that we're leaving reset mode. */
    2131         HDA_REG(pThis, GCTL) |= HDA_REG_FIELD_FLAG_MASK(GCTL, RST);
     2123        HDA_REG(pThis, GCTL) |= HDA_GCTL_CRST;
    21322124
    21332125        if (pThis->fInReset)
    … …  
    21422134        /* Enter reset state. */
    21432135        LogFunc(("Guest entering HDA reset with DMA(RIRB:%s, CORB:%s)\n",
    2144                  HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA) ? "on" : "off",
    2145                  HDA_REG_FLAG_VALUE(pThis, RIRBCTL, DMA) ? "on" : "off"));
     2136                 HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA ? "on" : "off",
     2137                 HDA_REG(pThis, RIRBCTL) & HDA_RIRBCTL_RDMAEN ? "on" : "off"));
    21462138
    21472139        /* Clear the CRST bit to indicate that we're in reset state. */
    2148         HDA_REG(pThis, GCTL) &= ~HDA_REG_FIELD_FLAG_MASK(GCTL, RST);
     2140        HDA_REG(pThis, GCTL) &= ~HDA_GCTL_CRST;
    21492141        pThis->fInReset = true;
    21502142
    … …  
    21552147    }
    21562148
    2157     if (u32Value & HDA_REG_FIELD_FLAG_MASK(GCTL, FSH))
     2149    if (u32Value & HDA_GCTL_FCNTRL)
    21582150    {
    21592151        /* Flush: GSTS:1 set, see 6.2.6. */
    2160         HDA_REG(pThis, GSTS) |= HDA_REG_FIELD_FLAG_MASK(GSTS, FSH); /* Set the flush state. */
     2152        HDA_REG(pThis, GSTS) |= HDA_GSTS_FSTS;  /* Set the flush status. */
    21612153        /* DPLBASE and DPUBASE should be initialized with initial value (see 6.2.6). */
    21622154    }
    … …  
    21832175
    21842176    /* Global Interrupt Enable (GIE) set? */
    2185     if (u32Value & HDA_INTCTL_GIE_MASK)
     2177    if (u32Value & HDA_INTCTL_GIE)
    21862178    {
    21872179        rc = hdaProcessInterrupt(pThis);
    … …  
    22262218    RT_NOREF_PV(iReg);
    22272219
    2228     if (u32Value & HDA_REG_FIELD_FLAG_MASK(CORBRP, RST))
     2220    if (u32Value & HDA_CORBRP_RST)
    22292221    {
    22302222        HDA_REG(pThis, CORBRP) = 0;
    … …  
    22422234    int rc = hdaRegWriteU8(pThis, iReg, u32Value);
    22432235    AssertRC(rc);
    2244     if (   HDA_REG(pThis, CORBWP)                  != HDA_REG(pThis, CORBRP)
    2245         && HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA) != 0)
     2236    if (   HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP)
     2237        && (HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
    22462238    {
    22472239        return hdaCORBCmdProcess(pThis);
    … …  
    22722264    if (HDA_REG(pThis, CORBWP) == HDA_REG(pThis, CORBRP))
    22732265        return VINF_SUCCESS;
    2274     if (!HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA))
     2266    if (!(HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
    22752267        return VINF_SUCCESS;
    22762268    rc = hdaCORBCmdProcess(pThis);
    … …  
    23232315    u32Value = (u32Value & 0x00ffffff);
    23242316
    2325     bool fRun      = RT_BOOL(u32Value & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
    2326     bool fInRun    = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
    2327 
    2328     bool fReset    = RT_BOOL(u32Value & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
    2329     bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST));
     2317    bool fRun      = RT_BOOL(u32Value & HDA_SDCTL_RUN);
     2318    bool fInRun    = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_RUN);
     2319
     2320    bool fReset    = RT_BOOL(u32Value & HDA_SDCTL_SRST);
     2321    bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_SRST);
    23302322
    23312323    /* Get the stream descriptor. */
    … …  
    23732365
    23742366        /* Report that we're done resetting this stream by clearing SRST. */
    2375         HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST);
     2367        HDA_STREAM_REG(pThis, CTL, uSD) &= ~HDA_SDCTL_SRST;
    23762368
    23772369        LogFunc(("[SD%RU8]: Reset exit\n", uSD));
    … …  
    29842976    /* regarding 3.4.3 we should mark IRS as busy in case CORB is active */
    29852977    if (   HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP)
    2986         || HDA_REG_FLAG_VALUE(pThis, CORBCTL, DMA))
    2987     {
    2988         HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, ICB);  /* busy */
     2978        || (HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
     2979    {
     2980        HDA_REG(pThis, IRS) = HDA_IRS_ICB;  /* busy */
    29892981    }
    29902982
    … …  
    30002992     * write the response to IR register, and set the IRV (valid in case of success) bit of IRS register.
    30012993     */
    3002     if (   u32Value & HDA_REG_FIELD_FLAG_MASK(IRS, ICB)
    3003         && !HDA_REG_FLAG_VALUE(pThis, IRS, ICB))
     2994    if (   (u32Value & HDA_IRS_ICB)
     2995        && !(HDA_REG(pThis, IRS) & HDA_IRS_ICB))
    30042996    {
    30052997#ifdef IN_RING3
    … …  
    30153007        }
    30163008
    3017         HDA_REG(pThis, IRS) = HDA_REG_FIELD_FLAG_MASK(IRS, ICB);  /* busy */
     3009        HDA_REG(pThis, IRS) = HDA_IRS_ICB;  /* busy */
    30183010
    30193011        uint64_t uResp;
    … …  
    30243016
    30253017        HDA_REG(pThis, IR)   = (uint32_t)uResp; /** @todo r=andy Do we need a 64-bit response? */
    3026         HDA_REG(pThis, IRS)  = HDA_REG_FIELD_FLAG_MASK(IRS, IRV);  /* result is ready  */
    3027         HDA_REG(pThis, IRS) &= ~HDA_REG_FIELD_FLAG_MASK(IRS, ICB); /* busy is clear */
     3018        HDA_REG(pThis, IRS)  = HDA_IRS_IRV;     /* result is ready  */
     3019        /** @todo r=michaln We just set the IRS value, why are we clearing unset bits? */
     3020        HDA_REG(pThis, IRS) &= ~HDA_IRS_ICB;    /* busy is clear */
    30283021        return VINF_SUCCESS;
    30293022#else  /* !IN_RING3 */
    … …  
    30333026
    30343027    /*
    3035      * Once the guest read the response, it should clean the IRV bit of the IRS register.
     3028     * Once the guest read the response, it should clear the IRV bit of the IRS register.
    30363029     */
    3037     if (   u32Value & HDA_REG_FIELD_FLAG_MASK(IRS, IRV)
    3038         && HDA_REG_FLAG_VALUE(pThis, IRS, IRV))
    3039         HDA_REG(pThis, IRS) &= ~HDA_REG_FIELD_FLAG_MASK(IRS, IRV);
     3030    HDA_REG(pThis, IRS) &= ~(u32Value & HDA_IRS_IRV);
    30403031    return VINF_SUCCESS;
    30413032}
    … …  
    30453036    RT_NOREF_PV(iReg);
    30463037
    3047     if (u32Value & HDA_REG_FIELD_FLAG_MASK(RIRBWP, RST))
     3038    if (u32Value & HDA_RIRBWP_RST)
    30483039        HDA_REG(pThis, RIRBWP) = 0;
    30493040
    … …  
    40844075
    40854076    /* Is the stream not in a running state currently? */
    4086     if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)))
     4077    if (!(HDA_STREAM_REG(pThis, CTL, pStream->u8SD) & HDA_SDCTL_RUN))
    40874078        fProceed = false;
    40884079    /* Is the BCIS (Buffer Completion Interrupt Status) flag set? Then we have to wait and skip. */
    … …  
    48974888
    48984889            /* Is the RUN bit currently set? */
    4899         if (   RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN))
     4890        if (   RT_BOOL(uSDCTL & HDA_SDCTL_RUN)
    49004891            /* Are writes to the register denied if RUN bit is set? */
    49014892            && !(g_aHdaRegMap[idxRegDsc].fFlags & HDA_RD_FLAG_SD_WRITE_RUN))
    … …  
    54655456                hdaStreamEnable(pThis, pStream, false /* fEnable */);
    54665457
    5467                 bool fActive = RT_BOOL(HDA_STREAM_REG(pThis, CTL, i) & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN));
     5458                bool fActive = RT_BOOL(HDA_STREAM_REG(pThis, CTL, i) & HDA_SDCTL_RUN);
    54685459                if (fActive)
    54695460                {
    … …  
    55145505                       "SDCTL(raw:%#x, DIR:%s, TP:%RTbool, STRIPE:%x, DEIE:%RTbool, FEIE:%RTbool, IOCE:%RTbool, RUN:%RTbool, RESET:%RTbool)",
    55155506                       uSDCTL,
    5516                        (uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, DIR)) ? "OUT" : "IN",
    5517                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, TP)),
    5518                        (uSDCTL & HDA_REG_FIELD_MASK(SDCTL, STRIPE)) >> HDA_SDCTL_STRIPE_SHIFT,
    5519                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, DEIE)),
    5520                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, FEIE)),
    5521                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, ICE)),
    5522                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN)),
    5523                        RT_BOOL(uSDCTL & HDA_REG_FIELD_FLAG_MASK(SDCTL, SRST)));
     5507                       uSDCTL & HDA_SDCTL_DIR ? "OUT" : "IN",
     5508                       RT_BOOL(uSDCTL & HDA_SDCTL_TP),
     5509                       (uSDCTL & HDA_SDCTL_STRIPE_MASK) >> HDA_SDCTL_STRIPE_SHIFT,
     5510                       RT_BOOL(uSDCTL & HDA_SDCTL_DEIE),
     5511                       RT_BOOL(uSDCTL & HDA_SDCTL_FEIE),
     5512                       RT_BOOL(uSDCTL & HDA_SDCTL_IOCE),
     5513                       RT_BOOL(uSDCTL & HDA_SDCTL_RUN),
     5514                       RT_BOOL(uSDCTL & HDA_SDCTL_SRST));
    55245515}
    55255516
    … …  
    58725863    {
    58735864        /* Remove the RUN bit from SDnCTL in case the stream was in a running state before. */
    5874         HDA_STREAM_REG(pThis, CTL, i) &= ~HDA_REG_FIELD_FLAG_MASK(SDCTL, RUN);
     5865        HDA_STREAM_REG(pThis, CTL, i) &= ~HDA_SDCTL_RUN;
    58755866        hdaStreamReset(pThis, &pThis->aStreams[i]);
    58765867    }
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