VirtualBox

Changeset 89778 in vbox


Ignore:
Timestamp:
Jun 18, 2021 1:20:11 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
145231
Message:

DevIchAc97: Eliminated the pRegs variables, just use pStream->Regs. instead. bugref:9890

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r89776 r89778  
    443443typedef struct AC97STREAM
    444444{
     445    /** Bus master registers of this stream. */
     446    AC97BMREGS              Regs;
    445447    /** Stream number (SDn). */
    446448    uint8_t                 u8SD;
    447449    uint8_t                 abPadding0[7];
    448     /** Bus master registers of this stream. */
    449     AC97BMREGS              Regs;
    450450
    451451    /** The timer for pumping data thru the attached LUN drivers. */
    … …  
    10181018    ichac97R3StreamLock(pStreamCC);
    10191019
    1020     PAC97BMREGS pRegs = &pStream->Regs;
    1021 
    10221020    /*
    10231021     * Check that the controller is not halted (DCH) and that the buffer
    … …  
    10421040     *        I just wish there was some clear reasoning in the source code for
    10431041     *        weird shit like this.  This is just random voodoo.  Sigh^3! */
    1044     if (!(pRegs->sr & (AC97_SR_DCH | AC97_SR_BCIS))) /* Controller halted? */
     1042    if (!(pStream->Regs.sr & (AC97_SR_DCH | AC97_SR_BCIS))) /* Controller halted? */
    10451043    { /* not halted nor does it have pending interrupt - likely */ }
    10461044    else
    10471045    {
    10481046        /** @todo Stop DMA timer when DCH is set. */
    1049         if (pRegs->sr & AC97_SR_DCH)
     1047        if (pStream->Regs.sr & AC97_SR_DCH)
    10501048        {
    10511049            STAM_REL_COUNTER_INC(&pStreamCC->State.StatDmaSkippedDch);
    10521050            LogFunc(("[SD%RU8] DCH set\n", pStream->u8SD));
    10531051        }
    1054         if (pRegs->sr & AC97_SR_BCIS)
     1052        if (pStream->Regs.sr & AC97_SR_BCIS)
    10551053        {
    10561054            STAM_REL_COUNTER_INC(&pStreamCC->State.StatDmaSkippedPendingBcis);
    10571055            LogFunc(("[SD%RU8] BCIS set\n", pStream->u8SD));
    10581056        }
    1059         if ((pRegs->cr & AC97_CR_RPBM) /* Bus master operation started. */ && !fInput)
     1057        if ((pStream->Regs.cr & AC97_CR_RPBM) /* Bus master operation started. */ && !fInput)
    10601058        {
    10611059            /*ichac97R3WriteBUP(pThis, cbToProcess);*/
    … …  
    10751073    PRTCIRCBUF pCircBuf         = pStreamCC->State.pCircBuf;
    10761074    AssertReturnStmt(pCircBuf, ichac97R3StreamUnlock(pStreamCC), VINF_SUCCESS);
    1077     Assert((uint32_t)pRegs->picb * PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props) >= cbToProcess);
    1078     Log3Func(("[SD%RU8] cbToProcess=%#x PICB=%#x/%#x\n",
    1079               pStream->u8SD, cbToProcess, pRegs->picb, pRegs->picb * PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props)));
     1075    Assert((uint32_t)pStream->Regs.picb * PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props) >= cbToProcess);
     1076    Log3Func(("[SD%RU8] cbToProcess=%#x PICB=%#x/%#x\n", pStream->u8SD, cbToProcess,
     1077              pStream->Regs.picb, pStream->Regs.picb * PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props)));
    10801078
    10811079    while (cbToProcess > 0)
    … …  
    10941092            if (cbDst)
    10951093            {
    1096                 int rc2 = PDMDevHlpPCIPhysRead(pDevIns, pRegs->bd.addr, pvDst, cbDst);
     1094                int rc2 = PDMDevHlpPCIPhysRead(pDevIns, pStream->Regs.bd.addr, pvDst, cbDst);
    10971095                AssertRC(rc2);
    10981096
    … …  
    11181116            if (cbSrc)
    11191117            {
    1120                 int rc2 = PDMDevHlpPCIPhysWrite(pDevIns, pRegs->bd.addr, pvSrc, cbSrc);
     1118                int rc2 = PDMDevHlpPCIPhysWrite(pDevIns, pStream->Regs.bd.addr, pvSrc, cbSrc);
    11211119                AssertRC(rc2);
    11221120
    … …  
    11381136            cbChunk = PDMAudioPropsFloorBytesToFrame(&pStreamCC->State.Cfg.Props, cbChunk);
    11391137
    1140             int rc2 = PDMDevHlpPCIPhysWrite(pDevIns, pRegs->bd.addr, g_abRTZero64K, cbChunk);
     1138            int rc2 = PDMDevHlpPCIPhysWrite(pDevIns, pStream->Regs.bd.addr, g_abRTZero64K, cbChunk);
    11411139            AssertRC(rc2);
    11421140        }
    … …  
    11481146         * Advance.
    11491147         */
    1150         pRegs->picb          -= cbChunk / PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props);
    1151         pRegs->bd.addr      += cbChunk;
    1152         cbToProcess          -= cbChunk;
     1148        pStream->Regs.picb    -= cbChunk / PDMAudioPropsSampleSize(&pStreamCC->State.Cfg.Props);
     1149        pStream->Regs.bd.addr += cbChunk;
     1150        cbToProcess           -= cbChunk;
    11531151#ifdef LOG_ENABLED
    1154         cbProcessedTotal     += cbChunk;
     1152        cbProcessedTotal      += cbChunk;
    11551153#endif
    11561154        LogFlowFunc(("[SD%RU8] cbChunk=%#x, cbToProcess=%#x, cbTotal=%#x picb=%#x\n",
    1157                      pStream->u8SD, cbChunk, cbToProcess, cbProcessedTotal, pRegs->picb));
     1155                     pStream->u8SD, cbChunk, cbToProcess, cbProcessedTotal, pStream->Regs.picb));
    11581156    }
    11591157
    … …  
    11611159     * Fetch a new buffer descriptor if we've exhausted the current one.
    11621160     */
    1163     if (!pRegs->picb)
    1164     {
    1165         uint32_t fNewSr = pRegs->sr & ~AC97_SR_CELV;
    1166 
    1167         if (pRegs->bd.ctl_len & AC97_BD_IOC)
     1161    if (!pStream->Regs.picb)
     1162    {
     1163        uint32_t fNewSr = pStream->Regs.sr & ~AC97_SR_CELV;
     1164
     1165        if (pStream->Regs.bd.ctl_len & AC97_BD_IOC)
    11681166            fNewSr |= AC97_SR_BCIS;
    11691167
    1170         if (pRegs->civ != pRegs->lvi)
     1168        if (pStream->Regs.civ != pStream->Regs.lvi)
    11711169            fNewSr |= ichac97R3StreamFetchNextBdle(pDevIns, pStream, pStreamCC);
    11721170        else
    11731171        {
    1174             LogFunc(("Underrun CIV (%RU8) == LVI (%RU8)\n", pRegs->civ, pRegs->lvi));
     1172            LogFunc(("Underrun CIV (%RU8) == LVI (%RU8)\n", pStream->Regs.civ, pStream->Regs.lvi));
    11751173            fNewSr |= AC97_SR_LVBCI | AC97_SR_DCH | AC97_SR_CELV;
    1176             pThis->bup_flag = (pRegs->bd.ctl_len & AC97_BD_BUP) ? BUP_LAST : 0;
     1174            pThis->bup_flag = (pStream->Regs.bd.ctl_len & AC97_BD_BUP) ? BUP_LAST : 0;
    11771175            /** @todo r=bird: The bup_flag isn't cleared anywhere else.  We should probably
    11781176             *        do what the spec says, and keep writing zeros (silence).
    … …  
    16361634static void ichac97StreamUpdateSR(PPDMDEVINS pDevIns, PAC97STATE pThis, PAC97STREAM pStream, uint32_t new_sr)
    16371635{
    1638     PAC97BMREGS pRegs   = &pStream->Regs;
    1639 
    16401636    bool fSignal = false;
    16411637    int  iIRQL = 0;
    16421638
    16431639    uint32_t new_mask = new_sr & AC97_SR_INT_MASK;
    1644     uint32_t old_mask = pRegs->sr & AC97_SR_INT_MASK;
     1640    uint32_t old_mask = pStream->Regs.sr & AC97_SR_INT_MASK;
    16451641
    16461642    if (new_mask ^ old_mask)
    … …  
    16521648            iIRQL   = 0;
    16531649        }
    1654         else if ((new_mask & AC97_SR_LVBCI) && (pRegs->cr & AC97_CR_LVBIE))
     1650        else if ((new_mask & AC97_SR_LVBCI) && (pStream->Regs.cr & AC97_CR_LVBIE))
    16551651        {
    16561652            fSignal = true;
    16571653            iIRQL   = 1;
    16581654        }
    1659         else if ((new_mask & AC97_SR_BCIS) && (pRegs->cr & AC97_CR_IOCE))
     1655        else if ((new_mask & AC97_SR_BCIS) && (pStream->Regs.cr & AC97_CR_IOCE))
    16601656        {
    16611657            fSignal = true;
    … …  
    16641660    }
    16651661
    1666     pRegs->sr = new_sr;
     1662    pStream->Regs.sr = new_sr;
    16671663
    16681664    LogFlowFunc(("IOC%d, LVB%d, sr=%#x, fSignal=%RTbool, IRQL=%d\n",
    1669                  pRegs->sr & AC97_SR_BCIS, pRegs->sr & AC97_SR_LVBCI, pRegs->sr, fSignal, iIRQL));
     1665                 pStream->Regs.sr & AC97_SR_BCIS, pStream->Regs.sr & AC97_SR_LVBCI, pStream->Regs.sr, fSignal, iIRQL));
    16701666
    16711667    if (fSignal)
    … …  
    16931689static void ichac97StreamWriteSR(PPDMDEVINS pDevIns, PAC97STATE pThis, PAC97STREAM pStream, uint32_t u32Val)
    16941690{
    1695     PAC97BMREGS pRegs = &pStream->Regs;
    1696 
    1697     Log3Func(("[SD%RU8] SR <- %#x (sr %#x)\n", pStream->u8SD, u32Val, pRegs->sr));
    1698 
    1699     pRegs->sr |= u32Val & ~(AC97_SR_RO_MASK | AC97_SR_WCLEAR_MASK);
    1700     ichac97StreamUpdateSR(pDevIns, pThis, pStream, pRegs->sr & ~(u32Val & AC97_SR_WCLEAR_MASK));
     1691    Log3Func(("[SD%RU8] SR <- %#x (sr %#x)\n", pStream->u8SD, u32Val, pStream->Regs.sr));
     1692
     1693    pStream->Regs.sr |= u32Val & ~(AC97_SR_RO_MASK | AC97_SR_WCLEAR_MASK);
     1694    ichac97StreamUpdateSR(pDevIns, pThis, pStream, pStream->Regs.sr & ~(u32Val & AC97_SR_WCLEAR_MASK));
    17011695}
    17021696
    … …  
    17191713        RTCircBufReset(pStreamCC->State.pCircBuf);
    17201714
    1721     PAC97BMREGS pRegs = &pStream->Regs;
    1722 
    1723     pRegs->bdbar    = 0;
    1724     pRegs->civ      = 0;
    1725     pRegs->lvi      = 0;
    1726 
    1727     pRegs->picb     = 0;
    1728     pRegs->piv      = 0; /* Note! Because this is also zero, we will actually start transferring with BDLE00. */
    1729     pRegs->cr      &= AC97_CR_DONT_CLEAR_MASK;
    1730     pRegs->bd_valid = 0;
     1715    pStream->Regs.bdbar    = 0;
     1716    pStream->Regs.civ      = 0;
     1717    pStream->Regs.lvi      = 0;
     1718
     1719    pStream->Regs.picb     = 0;
     1720    pStream->Regs.piv      = 0; /* Note! Because this is also zero, we will actually start transferring with BDLE00. */
     1721    pStream->Regs.cr      &= AC97_CR_DONT_CLEAR_MASK;
     1722    pStream->Regs.bd_valid = 0;
    17311723
    17321724    RT_ZERO(pThis->silence);
    … …  
    24852477    {
    24862478        PAC97STREAM pStream = &pThis->aStreams[AC97_PORT2IDX(offPort)];
    2487         PAC97BMREGS pRegs   = &pStream->Regs;
    24882479
    24892480        switch (cb)
    … …  
    24942485                    case AC97_NABM_OFF_CIV:
    24952486                        /* Current Index Value Register */
    2496                         *pu32 = pRegs->civ;
     2487                        *pu32 = pStream->Regs.civ;
    24972488                        Log3Func(("CIV[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    24982489                        break;
    24992490                    case AC97_NABM_OFF_LVI:
    25002491                        /* Last Valid Index Register */
    2501                         *pu32 = pRegs->lvi;
     2492                        *pu32 = pStream->Regs.lvi;
    25022493                        Log3Func(("LVI[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25032494                        break;
    25042495                    case AC97_NABM_OFF_PIV:
    25052496                        /* Prefetched Index Value Register */
    2506                         *pu32 = pRegs->piv;
     2497                        *pu32 = pStream->Regs.piv;
    25072498                        Log3Func(("PIV[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25082499                        break;
    25092500                    case AC97_NABM_OFF_CR:
    25102501                        /* Control Register */
    2511                         *pu32 = pRegs->cr;
     2502                        *pu32 = pStream->Regs.cr;
    25122503                        Log3Func(("CR[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25132504                        break;
    25142505                    case AC97_NABM_OFF_SR:
    25152506                        /* Status Register (lower part) */
    2516                         *pu32 = RT_LO_U8(pRegs->sr);
     2507                        *pu32 = RT_LO_U8(pStream->Regs.sr);
    25172508                        Log3Func(("SRb[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25182509                        break;
    … …  
    25302521                    case AC97_NABM_OFF_SR:
    25312522                        /* Status Register */
    2532                         *pu32 = pRegs->sr;
     2523                        *pu32 = pStream->Regs.sr;
    25332524                        Log3Func(("SR[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25342525                        break;
    … …  
    25452536                         * not sure if it's worth it, as it'll be a big complication... */
    25462537#if 1
    2547                         *pu32 = pRegs->picb;
     2538                        *pu32 = pStream->Regs.picb;
    25482539# ifdef LOG_ENABLED
    25492540                        if (LogIs3Enabled())
    … …  
    25742565                            else
    25752566                                cSamples = 0;
    2576                             *pu32 = pRegs->picb - cSamples;
     2567                            *pu32 = pStream->Regs.picb - cSamples;
    25772568                            Log3Func(("PICB[%d] -> %#x (PICB=%#x cSamples=%#x offPeriod=%RU64 of %RU64 / %RU64%%)\n",
    2578                                       AC97_PORT2IDX(offPort), *pu32, pRegs->picb, cSamples, offPeriod, pStream->cDmaPeriodTicks,
    2579                                       offPeriod * 100 / pStream->cDmaPeriodTicks));
     2569                                      AC97_PORT2IDX(offPort), *pu32, pStream->Regs.picb, cSamples, offPeriod,
     2570                                      pStream->cDmaPeriodTicks, offPeriod * 100 / pStream->cDmaPeriodTicks));
    25802571                        }
    25812572                        else
    25822573                        {
    2583                             *pu32 = pRegs->picb;
     2574                            *pu32 = pStream->Regs.picb;
    25842575                            Log3Func(("PICB[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    25852576                        }
    … …  
    25992590                    case AC97_NABM_OFF_BDBAR:
    26002591                        /* Buffer Descriptor Base Address Register */
    2601                         *pu32 = pRegs->bdbar;
     2592                        *pu32 = pStream->Regs.bdbar;
    26022593                        Log3Func(("BMADDR[%d] -> %#x\n", AC97_PORT2IDX(offPort), *pu32));
    26032594                        break;
    … …  
    26062597                         *                Last Valid Index Register +
    26072598                         *                Status Register */
    2608                         *pu32 = pRegs->civ | ((uint32_t)pRegs->lvi << 8) | ((uint32_t)pRegs->sr << 16);
     2599                        *pu32 = pStream->Regs.civ | ((uint32_t)pStream->Regs.lvi << 8) | ((uint32_t)pStream->Regs.sr << 16);
    26092600                        Log3Func(("CIV LVI SR[%d] -> %#x, %#x, %#x\n",
    2610                                   AC97_PORT2IDX(offPort), pRegs->civ, pRegs->lvi, pRegs->sr));
     2601                                  AC97_PORT2IDX(offPort), pStream->Regs.civ, pStream->Regs.lvi, pStream->Regs.sr));
    26112602                        break;
    26122603                    case AC97_NABM_OFF_PICB:
    … …  
    26142605                         *                Prefetched Index Value Register +
    26152606                         *                Control Register */
    2616                         *pu32 = pRegs->picb | ((uint32_t)pRegs->piv << 16) | ((uint32_t)pRegs->cr << 24);
     2607                        *pu32 = pStream->Regs.picb | ((uint32_t)pStream->Regs.piv << 16) | ((uint32_t)pStream->Regs.cr << 24);
    26172608                        Log3Func(("PICB PIV CR[%d] -> %#x %#x %#x %#x\n",
    2618                                   AC97_PORT2IDX(offPort), *pu32, pRegs->picb, pRegs->piv, pRegs->cr));
     2609                                  AC97_PORT2IDX(offPort), *pu32, pStream->Regs.picb, pStream->Regs.piv, pStream->Regs.cr));
    26192610                        break;
    26202611
    … …  
    27132704#endif
    27142705        PAC97STREAM     pStream   = &pThis->aStreams[AC97_PORT2IDX(offPort)];
    2715         PAC97BMREGS     pRegs     = &pStream->Regs;
    27162706
    27172707        switch (cb)
    … …  
    27262716                        DEVAC97_LOCK_RETURN(pDevIns, pThis, VINF_IOM_R3_IOPORT_WRITE);
    27272717
    2728                         if (   !(pRegs->sr & AC97_SR_DCH)
    2729                             || !(pRegs->cr & AC97_CR_RPBM))
     2718                        if (   !(pStream->Regs.sr & AC97_SR_DCH)
     2719                            || !(pStream->Regs.cr & AC97_CR_RPBM))
    27302720                        {
    2731                             pRegs->lvi = u32 % AC97_MAX_BDLE;
     2721                            pStream->Regs.lvi = u32 % AC97_MAX_BDLE;
    27322722                            STAM_REL_COUNTER_INC(&pStream->StatWriteLvi);
    27332723                            DEVAC97_UNLOCK(pDevIns, pThis);
    … …  
    27422732                               we cannot do this from ring-3 as much of the BDLE state is
    27432733                               ring-3 only. */
    2744                             pRegs->sr &= ~(AC97_SR_DCH | AC97_SR_CELV);
    2745                             pRegs->lvi = u32 % AC97_MAX_BDLE;
     2734                            pStream->Regs.sr &= ~(AC97_SR_DCH | AC97_SR_CELV);
     2735                            pStream->Regs.lvi = u32 % AC97_MAX_BDLE;
    27462736                            if (ichac97R3StreamFetchNextBdle(pDevIns, pStream, pStreamCC))
    2747                                 ichac97StreamUpdateSR(pDevIns, pThis, pStream, pRegs->sr | AC97_SR_BCIS);
     2737                                ichac97StreamUpdateSR(pDevIns, pThis, pStream, pStream->Regs.sr | AC97_SR_BCIS);
    27482738
    27492739                            /* We now have to re-arm the DMA timer according to the new BDLE length.
    … …  
    27582748
    27592749                            LogFunc(("[SD%RU8] LVI <- %#x; CIV=%#x PIV=%#x SR=%#x cTicksToDeadline=%#RX64 [recovering]\n",
    2760                                      pStream->u8SD, u32, pRegs->civ, pRegs->piv, pRegs->sr, cTicksToDeadline));
     2750                                     pStream->u8SD, u32, pStream->Regs.civ, pStream->Regs.piv, pStream->Regs.sr, cTicksToDeadline));
    27612751
    27622752                            int rc2 = PDMDevHlpTimerSetRelative(pDevIns, pStream->hTimer, cTicksToDeadline, &pStream->uArmedTs);
    … …  
    27772767                        STAM_REL_COUNTER_INC(&pStreamCC->State.StatWriteCr);
    27782768
    2779                         uint32_t const fCrChanged = pRegs->cr ^ u32;
    2780                         Log3Func(("[SD%RU8] CR <- %#x (was %#x; changed %#x)\n", pStream->u8SD, u32, pRegs->cr, fCrChanged));
     2769                        uint32_t const fCrChanged = pStream->Regs.cr ^ u32;
     2770                        Log3Func(("[SD%RU8] CR <- %#x (was %#x; changed %#x)\n", pStream->u8SD, u32, pStream->Regs.cr, fCrChanged));
    27812771
    27822772                        /*
    … …  
    27912781                               3.2.7 in 302349-003 says RPBM be must be clear when resetting
    27922782                               and that behavior is undefined if it's set. */
    2793                             ASSERT_GUEST_STMT((pRegs->cr & AC97_CR_RPBM) == 0,
     2783                            ASSERT_GUEST_STMT((pStream->Regs.cr & AC97_CR_RPBM) == 0,
    27942784                                              ichac97R3StreamEnable(pDevIns, pThis, pThisCC, pStream,
    27952785                                                                    pStreamCC, false /* fEnable */));
    … …  
    28072797                         * Write the new value to the register and if RPBM didn't change we're done.
    28082798                         */
    2809                         pRegs->cr = u32 & AC97_CR_VALID_MASK;
     2799                        pStream->Regs.cr = u32 & AC97_CR_VALID_MASK;
    28102800
    28112801                        if (!(fCrChanged & AC97_CR_RPBM))
    … …  
    28142804                         * Pause busmaster.
    28152805                         */
    2816                         else if (!(pRegs->cr & AC97_CR_RPBM))
     2806                        else if (!(pStream->Regs.cr & AC97_CR_RPBM))
    28172807                        {
    28182808                            STAM_REL_PROFILE_START_NS(&pStreamCC->State.StatStop, p);
    28192809                            LogFunc(("[SD%RU8] Pause busmaster (disable stream) SR=%#x -> %#x\n",
    2820                                      pStream->u8SD, pRegs->sr, pRegs->sr | AC97_SR_DCH));
     2810                                     pStream->u8SD, pStream->Regs.sr, pStream->Regs.sr | AC97_SR_DCH));
    28212811                            ichac97R3StreamEnable(pDevIns, pThis, pThisCC, pStream, pStreamCC, false /* fEnable */);
    2822                             pRegs->sr |= AC97_SR_DCH;
     2812                            pStream->Regs.sr |= AC97_SR_DCH;
    28232813
    28242814                            DEVAC97_UNLOCK(pDevIns, pThis);
    … …  
    28322822                            STAM_REL_PROFILE_START_NS(&pStreamCC->State.StatStart, r);
    28332823                            LogFunc(("[SD%RU8] Run busmaster (enable stream) SR=%#x -> %#x\n",
    2834                                      pStream->u8SD, pRegs->sr, pRegs->sr & ~AC97_SR_DCH));
    2835                             pRegs->sr &= ~AC97_SR_DCH;
     2824                                     pStream->u8SD, pStream->Regs.sr, pStream->Regs.sr & ~AC97_SR_DCH));
     2825                            pStream->Regs.sr &= ~AC97_SR_DCH;
    28362826
    28372827                            if (ichac97R3StreamFetchNextBdle(pDevIns, pStream, pStreamCC))
    2838                                 ichac97StreamUpdateSR(pDevIns, pThis, pStream, pRegs->sr | AC97_SR_BCIS);
     2828                                ichac97StreamUpdateSR(pDevIns, pThis, pStream, pStream->Regs.sr | AC97_SR_BCIS);
    28392829# ifdef LOG_ENABLED
    28402830                            if (LogIsFlowEnabled())
    … …  
    29072897                        DEVAC97_LOCK_RETURN(pDevIns, pThis, VINF_IOM_R3_IOPORT_WRITE);
    29082898                        /* Buffer Descriptor list Base Address Register */
    2909                         pRegs->bdbar = u32 & ~(uint32_t)3;
    2910                         Log3Func(("[SD%RU8] BDBAR <- %#x (bdbar %#x)\n", AC97_PORT2IDX(offPort), u32, pRegs->bdbar));
     2899                        pStream->Regs.bdbar = u32 & ~(uint32_t)3;
     2900                        Log3Func(("[SD%RU8] BDBAR <- %#x (bdbar %#x)\n", AC97_PORT2IDX(offPort), u32, pStream->Regs.bdbar));
    29112901                        STAM_REL_COUNTER_INC(&pStream->StatWriteBdBar);
    29122902                        DEVAC97_UNLOCK(pDevIns, pThis);
    … …  
    36613651static void ichac97R3SaveStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStream)
    36623652{
    3663     PAC97BMREGS   pRegs = &pStream->Regs;
    36643653    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
    36653654
    3666     pHlp->pfnSSMPutU32(pSSM, pRegs->bdbar);
    3667     pHlp->pfnSSMPutU8( pSSM, pRegs->civ);
    3668     pHlp->pfnSSMPutU8( pSSM, pRegs->lvi);
    3669     pHlp->pfnSSMPutU16(pSSM, pRegs->sr);
    3670     pHlp->pfnSSMPutU16(pSSM, pRegs->picb);
    3671     pHlp->pfnSSMPutU8( pSSM, pRegs->piv);
    3672     pHlp->pfnSSMPutU8( pSSM, pRegs->cr);
    3673     pHlp->pfnSSMPutS32(pSSM, pRegs->bd_valid);
    3674     pHlp->pfnSSMPutU32(pSSM, pRegs->bd.addr);
    3675     pHlp->pfnSSMPutU32(pSSM, pRegs->bd.ctl_len);
     3655    pHlp->pfnSSMPutU32(pSSM, pStream->Regs.bdbar);
     3656    pHlp->pfnSSMPutU8( pSSM, pStream->Regs.civ);
     3657    pHlp->pfnSSMPutU8( pSSM, pStream->Regs.lvi);
     3658    pHlp->pfnSSMPutU16(pSSM, pStream->Regs.sr);
     3659    pHlp->pfnSSMPutU16(pSSM, pStream->Regs.picb);
     3660    pHlp->pfnSSMPutU8( pSSM, pStream->Regs.piv);
     3661    pHlp->pfnSSMPutU8( pSSM, pStream->Regs.cr);
     3662    pHlp->pfnSSMPutS32(pSSM, pStream->Regs.bd_valid);
     3663    pHlp->pfnSSMPutU32(pSSM, pStream->Regs.bd.addr);
     3664    pHlp->pfnSSMPutU32(pSSM, pStream->Regs.bd.ctl_len);
    36763665}
    36773666
    … …  
    37233712static int ichac97R3LoadStream(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PAC97STREAM pStream)
    37243713{
    3725     PAC97BMREGS   pRegs = &pStream->Regs;
    37263714    PCPDMDEVHLPR3 pHlp  = pDevIns->pHlpR3;
    37273715
    3728     pHlp->pfnSSMGetU32(pSSM, &pRegs->bdbar);
    3729     pHlp->pfnSSMGetU8( pSSM, &pRegs->civ);
    3730     pHlp->pfnSSMGetU8( pSSM, &pRegs->lvi);
    3731     pHlp->pfnSSMGetU16(pSSM, &pRegs->sr);
    3732     pHlp->pfnSSMGetU16(pSSM, &pRegs->picb);
    3733     pHlp->pfnSSMGetU8( pSSM, &pRegs->piv);
    3734     pHlp->pfnSSMGetU8( pSSM, &pRegs->cr);
    3735     pHlp->pfnSSMGetS32(pSSM, &pRegs->bd_valid);
    3736     pHlp->pfnSSMGetU32(pSSM, &pRegs->bd.addr);
    3737     return pHlp->pfnSSMGetU32(pSSM, &pRegs->bd.ctl_len);
     3716    pHlp->pfnSSMGetU32(pSSM, &pStream->Regs.bdbar);
     3717    pHlp->pfnSSMGetU8( pSSM, &pStream->Regs.civ);
     3718    pHlp->pfnSSMGetU8( pSSM, &pStream->Regs.lvi);
     3719    pHlp->pfnSSMGetU16(pSSM, &pStream->Regs.sr);
     3720    pHlp->pfnSSMGetU16(pSSM, &pStream->Regs.picb);
     3721    pHlp->pfnSSMGetU8( pSSM, &pStream->Regs.piv);
     3722    pHlp->pfnSSMGetU8( pSSM, &pStream->Regs.cr);
     3723    pHlp->pfnSSMGetS32(pSSM, &pStream->Regs.bd_valid);
     3724    pHlp->pfnSSMGetU32(pSSM, &pStream->Regs.bd.addr);
     3725    return pHlp->pfnSSMGetU32(pSSM, &pStream->Regs.bd.ctl_len);
    37383726}
    37393727
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