VirtualBox

Changeset 82323 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Dec 2, 2019 2:33:12 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
135147
Message:

DevIchAc97,DevHDA: PDMCritSect -> PDMDevHlpCritSect. No need to take the locks again in the timer callback. Removed incorrect unlocking/locking around hdaR3TimerSet call in hdaR3StreamTransfer (didn't do much with the double locking, but makes a difference now that that has been eliminated). bugref:9218

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

Legend:

Unmodified
Added
Removed

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

    r82319 r82323  
    155155 * Acquires the TM lock and HDA lock, returns on failure.
    156156 */
    157 #define DEVHDA_LOCK_BOTH_RETURN_VOID(a_pDevIns, a_pThis, a_SD) \
    158     do { \
    159         int rcLock = TMTimerLock((a_pThis)->pTimer[a_SD], VERR_IGNORED); \
    160         if (rcLock == VINF_SUCCESS) \
    161         { /* likely */ } \
    162         else \
    163         { \
    164             AssertRC(rcLock); \
    165             return; \
    166         } \
    167         rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    168         if (rcLock == VINF_SUCCESS) \
    169         { /* likely */ } \
    170         else \
    171         { \
    172             AssertRC(rcLock); \
    173             TMTimerUnlock((a_pThis)->pTimer[a_SD]); \
    174             return; \
    175         } \
    176     } while (0)
    177 
    178 /**
    179  * Acquires the TM lock and HDA lock, returns on failure.
    180  */
    181157#define DEVHDA_LOCK_BOTH_RETURN(a_pDevIns, a_pThis, a_SD, a_rcBusy) \
    182158    do { \
    183159        int rcLock = TMTimerLock((a_pThis)->pTimer[a_SD], (a_rcBusy)); \
    184160        if (rcLock == VINF_SUCCESS) \
    185         { /* likely */ } \
    186         else \
    187161        { \
    188             AssertRC(rcLock); \
    189             return rcLock; \
     162            rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
     163            if (rcLock == VINF_SUCCESS) \
     164                break; \
     165            TMTimerUnlock((a_pThis)->pTimer[a_SD]); \
    190166        } \
    191         rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
    192         if (rcLock == VINF_SUCCESS) \
    193         { /* likely */ } \
    194         else \
    195         { \
    196             AssertRC(rcLock); \
    197             TMTimerUnlock((a_pThis)->pTimer[a_SD]); \
    198             return rcLock; \
    199         } \
     167        AssertRC(rcLock); \
     168        return rcLock; \
    200169    } while (0)
    201170
    … …  
    13121281    const uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, CTL, iReg);
    13131282
    1314     DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, uSD, VINF_IOM_R3_MMIO_WRITE);
    1315 
    13161283    /*
    13171284     * Some guests write too much (that is, 32-bit with the top 8 bit being junk)
    … …  
    13191286     */
    13201287    u32Value &= 0x00ffffff;
    1321 
    1322     const bool fRun      = RT_BOOL(u32Value & HDA_SDCTL_RUN);
    1323     const bool fInRun    = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_RUN);
    1324 
    1325     const bool fReset    = RT_BOOL(u32Value & HDA_SDCTL_SRST);
    1326     const bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_SRST);
    1327 
    1328     /*LogFunc(("[SD%RU8] fRun=%RTbool, fInRun=%RTbool, fReset=%RTbool, fInReset=%RTbool, %R[sdctl]\n",
    1329                uSD, fRun, fInRun, fReset, fInReset, u32Value));*/
    13301288
    13311289    /*
    … …  
    13371295     */
    13381296    uint8_t uTag = (u32Value >> HDA_SDCTL_NUM_SHIFT) & HDA_SDCTL_NUM_MASK;
    1339     if (uTag > HDA_MAX_TAGS)
    1340     {
    1341         LogFunc(("[SD%RU8] Warning: Invalid stream tag %RU8 specified!\n", uSD, uTag));
    1342 
    1343         DEVHDA_UNLOCK_BOTH(pDevIns, pThis, uSD);
    1344         return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    1345     }
     1297    ASSERT_GUEST_MSG_RETURN(uTag < RT_ELEMENTS(pThis->aTags),
     1298                            ("SD%RU8: Invalid stream tag %RU8 (u32Value=%#x)!\n", uSD, uTag, u32Value),
     1299                            VINF_SUCCESS /* Always return success to the MMIO handler. */);
    13461300
    13471301    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
    1348     if (!pStream)
    1349     {
    1350         ASSERT_GUEST_LOGREL_MSG_FAILED(("Guest tried writing SDCTL (0x%x) to unhandled stream #%RU8\n", u32Value, uSD));
    1351 
    1352         DEVHDA_UNLOCK_BOTH(pDevIns, pThis, uSD);
    1353         return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    1354     }
    1355 
     1302    ASSERT_GUEST_LOGREL_MSG_RETURN(pStream, ("Guest tried writing SDCTL (0x%x) to unhandled stream #%RU8\n", u32Value, uSD),
     1303                                   VINF_SUCCESS /* Always return success to the MMIO handler. */);
     1304
     1305    const bool fRun      = RT_BOOL(u32Value & HDA_SDCTL_RUN);
     1306    const bool fReset    = RT_BOOL(u32Value & HDA_SDCTL_SRST);
     1307
     1308    /**
     1309     * @todo r=bird: Must reduce the time we holding the virtual sync
     1310     *               clock lock here!
     1311     */
     1312    DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, uSD, VINF_IOM_R3_MMIO_WRITE);
     1313
     1314    const bool fInRun    = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_RUN);
     1315    const bool fInReset  = RT_BOOL(HDA_REG_IND(pThis, iReg) & HDA_SDCTL_SRST);
     1316
     1317    /*LogFunc(("[SD%RU8] fRun=%RTbool, fInRun=%RTbool, fReset=%RTbool, fInReset=%RTbool, %R[sdctl]\n",
     1318               uSD, fRun, fInRun, fReset, fInReset, u32Value));*/
    13561319    if (fInReset)
    13571320    {
    … …  
    15141477#ifdef IN_RING3
    15151478    const uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, STS, iReg);
    1516 
     1479    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
     1480    ASSERT_GUEST_LOGREL_MSG_RETURN(pStream, ("Guest tried writing SDSTS (0x%x) to unhandled stream #%RU8\n", u32Value, uSD),
     1481                                   VINF_SUCCESS);
     1482
     1483    /**
     1484     * @todo r=bird: Must reduce the time we holding the virtual sync
     1485     *               clock lock here!
     1486     */
    15171487    DEVHDA_LOCK_BOTH_RETURN(pDevIns, pThis, uSD, VINF_IOM_R3_MMIO_WRITE);
    1518 
    1519     PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
    1520     if (!pStream)
    1521     {
    1522         ASSERT_GUEST_LOGREL_MSG_FAILED(("Guest tried writing SDSTS (0x%x) to unhandled stream #%RU8\n", u32Value, uSD));
    1523         DEVHDA_UNLOCK_BOTH(pDevIns, pThis, uSD);
    1524         return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    1525     }
    15261488
    15271489    hdaR3StreamLock(pStream);
    … …  
    28912853static DECLCALLBACK(void) hdaR3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    28922854{
     2855    PHDASTATE  pThis   = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
     2856    PHDASTREAM pStream = (PHDASTREAM)pvUser;
    28932857    RT_NOREF(pTimer);
    28942858
    2895     PHDASTREAM pStream = (PHDASTREAM)pvUser;
    28962859    AssertPtr(pStream);
    2897 
    2898     PHDASTATE  pThis   = pStream->pHDAState;
    2899 
    2900     DEVHDA_LOCK_BOTH_RETURN_VOID(pDevIns, pStream->pHDAState, pStream->u8SD);
     2860    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     2861    Assert(TMTimerIsLockOwner(pStream->pTimer));
    29012862
    29022863    hdaR3StreamUpdate(pStream, true /* fInTimer */);
    … …  
    29192880    else
    29202881        Log3Func(("fSinksActive=%RTbool\n", fSinkActive));
    2921 
    2922     DEVHDA_UNLOCK_BOTH(pDevIns, pThis, pStream->u8SD);
    29232882}
    29242883
    … …  
    52365195    PHDASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PHDASTATE);
    52375196
    5238     int rc = PDMDevHlpMmioSetUpContext(pDevIns, pThis->hMmio, hdaMMIOWrite, hdaMMIORead, NULL /*pvUser*/);
     5197    int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
     5198    AssertRCReturn(rc, rc);
     5199
     5200    rc = PDMDevHlpMmioSetUpContext(pDevIns, pThis->hMmio, hdaMMIOWrite, hdaMMIORead, NULL /*pvUser*/);
    52395201    AssertRCReturn(rc, rc);
    52405202

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

    r82252 r82323  
    256256PHDASTREAM hdaGetStreamFromSD(PHDASTATE pThis, uint8_t uSD)
    257257{
    258     AssertPtrReturn(pThis, NULL);
    259     AssertReturn(uSD < HDA_MAX_STREAMS, NULL);
    260 
    261     if (uSD >= HDA_MAX_STREAMS)
    262     {
    263         ASSERT_GUEST_LOGREL_MSG_FAILED(("Stream #%RU8 is invalid\n", uSD));
    264         return NULL;
    265     }
    266 
     258    AssertPtr(pThis);
     259    ASSERT_GUEST_MSG_RETURN(uSD < HDA_MAX_STREAMS, ("uSD=%u (%#x)\n", uSD, uSD), NULL);
    267260    return &pThis->aStreams[uSD];
    268261}

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

    r82319 r82323  
    549549 * Acquires the AC'97 lock.
    550550 */
    551 #define DEVAC97_LOCK(a_pThis) \
     551#define DEVAC97_LOCK(a_pDevIns, a_pThis) \
    552552    do { \
    553         int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
     553        int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, VERR_IGNORED); \
    554554        AssertRC(rcLock); \
    555555    } while (0)
    … …  
    558558 * Acquires the AC'97 lock or returns.
    559559 */
    560 # define DEVAC97_LOCK_RETURN(a_pThis, a_rcBusy) \
     560# define DEVAC97_LOCK_RETURN(a_pDevIns, a_pThis, a_rcBusy) \
    561561    do { \
    562         int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, a_rcBusy); \
    563         if (rcLock != VINF_SUCCESS) \
    564         { \
    565             AssertRC(rcLock); \
    566             return rcLock; \
    567         } \
     562        int rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, a_rcBusy); \
     563        if (rcLock == VINF_SUCCESS) \
     564            break; \
     565        AssertRC(rcLock); \
     566        return rcLock; \
    568567    } while (0)
    569568
    570 /**
    571  * Acquires the AC'97 lock or returns.
    572  */
    573 # define DEVAC97_LOCK_RETURN_VOID(a_pThis) \
    574     do { \
    575         int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
    576         if (rcLock != VINF_SUCCESS) \
    577         { \
    578             AssertRC(rcLock); \
    579             return; \
    580         } \
    581     } while (0)
    582 
    583 #ifdef IN_RC
    584569/** Retrieves an attribute from a specific audio stream in RC. */
    585 # define DEVAC97_CTX_SUFF_SD(a_Var, a_SD)      a_Var##RC[a_SD]
    586 #elif defined(IN_RING0)
    587 /** Retrieves an attribute from a specific audio stream in R0. */
    588 # define DEVAC97_CTX_SUFF_SD(a_Var, a_SD)      a_Var##R0[a_SD]
    589 #else
    590 /** Retrieves an attribute from a specific audio stream in R3. */
    591 # define DEVAC97_CTX_SUFF_SD(a_Var, a_SD)      a_Var##R3[a_SD]
    592 #endif
     570#define DEVAC97_CTX_SUFF_SD(a_Var, a_SD)      CTX_SUFF(a_Var)[a_SD]
    593571
    594572/**
    595573 * Releases the AC'97 lock.
    596574 */
    597 #define DEVAC97_UNLOCK(a_pThis) \
    598     do { PDMCritSectLeave(&(a_pThis)->CritSect); } while (0)
     575#define DEVAC97_UNLOCK(a_pDevIns, a_pThis) \
     576    do { PDMDevHlpCritSectLeave((a_pDevIns), &(a_pThis)->CritSect); } while (0)
    599577
    600578/**
    601579 * Acquires the TM lock and AC'97 lock, returns on failure.
    602580 */
    603 #define DEVAC97_LOCK_BOTH_RETURN_VOID(a_pThis, a_SD) \
    604     do { \
    605         int rcLock = TMTimerLock((a_pThis)->DEVAC97_CTX_SUFF_SD(pTimer, a_SD), VERR_IGNORED); \
    606         if (rcLock != VINF_SUCCESS) \
    607         { \
    608             AssertRC(rcLock); \
    609             return; \
    610         } \
    611         rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
    612         if (rcLock != VINF_SUCCESS) \
    613         { \
    614             AssertRC(rcLock); \
    615             TMTimerUnlock((a_pThis)->DEVAC97_CTX_SUFF_SD(pTimer, a_SD)); \
    616             return; \
    617         } \
    618     } while (0)
    619 
    620 /**
    621  * Acquires the TM lock and AC'97 lock, returns on failure.
    622  */
    623 #define DEVAC97_LOCK_BOTH_RETURN(a_pThis, a_SD, a_rcBusy) \
     581#define DEVAC97_LOCK_BOTH_RETURN(a_pDevIns, a_pThis, a_SD, a_rcBusy) \
    624582    do { \
    625583        int rcLock = TMTimerLock((a_pThis)->DEVAC97_CTX_SUFF_SD(pTimer, a_SD), (a_rcBusy)); \
    626         if (rcLock != VINF_SUCCESS) \
    627             return rcLock; \
    628         rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, (a_rcBusy)); \
    629         if (rcLock != VINF_SUCCESS) \
     584        if (rcLock == VINF_SUCCESS) \
    630585        { \
    631             AssertRC(rcLock); \
     586            rcLock = PDMDevHlpCritSectEnter((a_pDevIns), &(a_pThis)->CritSect, (a_rcBusy)); \
     587            if (rcLock == VINF_SUCCESS) \
     588                break; \
    632589            TMTimerUnlock((a_pThis)->DEVAC97_CTX_SUFF_SD(pTimer, a_SD)); \
    633             return rcLock; \
    634590        } \
     591        AssertRC(rcLock); \
     592        return rcLock; \
    635593    } while (0)
    636594
    … …  
    638596 * Releases the AC'97 lock and TM lock.
    639597 */
    640 #define DEVAC97_UNLOCK_BOTH(a_pThis, a_SD) \
     598#define DEVAC97_UNLOCK_BOTH(a_pDevIns, a_pThis, a_SD) \
    641599    do { \
    642         PDMCritSectLeave(&(a_pThis)->CritSect); \
     600        PDMDevHlpCritSectLeave((a_pDevIns), &(a_pThis)->CritSect); \
    643601        TMTimerUnlock((a_pThis)->DEVAC97_CTX_SUFF_SD(pTimer, a_SD)); \
    644602    } while (0)
    … …  
    26292587
    26302588/**
    2631  * Timer callback which handles the audio data transfers on a periodic basis.
    2632  *
    2633  * @param   pDevIns             Device instance.
    2634  * @param   pTimer              Timer which was used when calling this.
    2635  * @param   pvUser              User argument as PAC97STATE.
     2589 * @callback_method_impl{FNTMTIMERDEV,
     2590 * Timer callback which handles the audio data transfers on a periodic basis.}
    26362591 */
    26372592static DECLCALLBACK(void) ichac97R3Timer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    26382593{
    2639     RT_NOREF(pDevIns, pTimer);
    2640 
     2594    PAC97STATE  pThis   = PDMDEVINS_2_DATA(pDevIns, PAC97STATE);
     2595    STAM_PROFILE_START(&pThis->StatTimer, a);
    26412596    PAC97STREAM pStream = (PAC97STREAM)pvUser;
     2597    RT_NOREF(pTimer);
     2598
    26422599    AssertPtr(pStream);
    2643 
    2644     PAC97STATE  pThis   = pStream->pAC97State;
    2645     AssertPtr(pThis);
    2646 
    2647     STAM_PROFILE_START(&pThis->StatTimer, a);
    2648 
    2649     DEVAC97_LOCK_BOTH_RETURN_VOID(pThis, pStream->u8SD);
     2600    Assert(PDMDevHlpCritSectIsOwner(pDevIns, &pThis->CritSect));
     2601    Assert(TMTimerIsLockOwner((pThis)->DEVAC97_CTX_SUFF_SD(pTimer, pStream->u8SD)));
    26502602
    26512603    ichac97R3StreamUpdate(pThis, pStream, true /* fInTimer */);
    26522604
    26532605    PAUDMIXSINK pSink = ichac97R3IndexToSink(pThis, pStream->u8SD);
    2654 
    2655     bool fSinkActive = false;
    2656     if (pSink)
    2657         fSinkActive = AudioMixerSinkIsActive(pSink);
    2658 
    2659     if (fSinkActive)
     2606    if (pSink && AudioMixerSinkIsActive(pSink))
    26602607    {
    26612608        ichac97R3StreamTransferUpdate(pThis, pStream, pStream->Regs.picb << 1); /** @todo r=andy Assumes 16-bit samples. */
    26622609
    2663         ichac97TimerSet(pThis,pStream,
     2610        ichac97TimerSet(pThis, pStream,
    26642611                        TMTimerGet((pThis)->DEVAC97_CTX_SUFF_SD(pTimer, pStream->u8SD)) + pStream->State.cTransferTicks,
    26652612                        false /* fForce */);
    26662613    }
    26672614
    2668     DEVAC97_UNLOCK_BOTH(pThis, pStream->u8SD);
    2669 
    26702615    STAM_PROFILE_STOP(&pThis->StatTimer, a);
    26712616}
     2617
    26722618#endif /* IN_RING3 */
    26732619
    … …  
    29402886    RT_NOREF(pvUser);
    29412887
    2942     DEVAC97_LOCK_RETURN(pThis, VINF_IOM_R3_IOPORT_READ);
     2888    DEVAC97_LOCK_RETURN(pDevIns, pThis, VINF_IOM_R3_IOPORT_READ);
    29432889
    29442890    /* Get the index of the NABMBAR port. */
    … …  
    30913037    }
    30923038
    3093     DEVAC97_UNLOCK(pThis);
     3039    DEVAC97_UNLOCK(pDevIns, pThis);
    30943040
    30953041    return rc;
    … …  
    31133059        pRegs = &pStream->Regs;
    31143060
    3115         DEVAC97_LOCK_BOTH_RETURN(pThis, pStream->u8SD, VINF_IOM_R3_IOPORT_WRITE);
     3061        DEVAC97_LOCK_BOTH_RETURN(pDevIns, pThis, pStream->u8SD, VINF_IOM_R3_IOPORT_WRITE);
    31163062    }
    31173063
    … …  
    32883234
    32893235    if (pStream)
    3290         DEVAC97_UNLOCK_BOTH(pThis, pStream->u8SD);
     3236        DEVAC97_UNLOCK_BOTH(pDevIns, pThis, pStream->u8SD);
    32913237
    32923238    return rc;
    … …  
    33013247    PAC97STATE pThis = PDMDEVINS_2_DATA(pDevIns, PAC97STATE);
    33023248    RT_NOREF(pvUser);
    3303 
    3304     DEVAC97_LOCK_RETURN(pThis, VINF_IOM_R3_IOPORT_READ);
     3249    Assert(offPort < 256);
     3250
     3251    DEVAC97_LOCK_RETURN(pDevIns, pThis, VINF_IOM_R3_IOPORT_READ);
    33053252
    33063253    VBOXSTRICTRC rc = VINF_SUCCESS;
    3307 
    3308     Assert(offPort < 256);
    3309 
    33103254    switch (cb)
    33113255    {
    … …  
    33403284    }
    33413285
    3342     DEVAC97_UNLOCK(pThis);
     3286    DEVAC97_UNLOCK(pDevIns, pThis);
    33433287    return rc;
    33443288}
    … …  
    33533297    RT_NOREF(pvUser);
    33543298
    3355     DEVAC97_LOCK_RETURN(pThis, VINF_IOM_R3_IOPORT_WRITE);
     3299    DEVAC97_LOCK_RETURN(pDevIns, pThis, VINF_IOM_R3_IOPORT_WRITE);
    33563300
    33573301    VBOXSTRICTRC rc = VINF_SUCCESS;
    … …  
    35483492    }
    35493493
    3550     DEVAC97_UNLOCK(pThis);
     3494    DEVAC97_UNLOCK(pDevIns, pThis);
    35513495    return rc;
    35523496}
    … …  
    39353879    LogFunc(("iLUN=%u, fFlags=0x%x\n", iLUN, fFlags));
    39363880
    3937     DEVAC97_LOCK(pThis);
     3881    DEVAC97_LOCK(pDevIns, pThis);
    39383882
    39393883    PAC97DRIVER pDrv;
    … …  
    39453889        LogFunc(("Failed with %Rrc\n", rc2));
    39463890
    3947     DEVAC97_UNLOCK(pThis);
     3891    DEVAC97_UNLOCK(pDevIns, pThis);
    39483892
    39493893    return VINF_SUCCESS;
    … …  
    39593903    LogFunc(("iLUN=%u, fFlags=0x%x\n", iLUN, fFlags));
    39603904
    3961     DEVAC97_LOCK(pThis);
     3905    DEVAC97_LOCK(pDevIns, pThis);
    39623906
    39633907    PAC97DRIVER pDrv, pDrvNext;
    … …  
    39783922    }
    39793923
    3980     DEVAC97_UNLOCK(pThis);
     3924    DEVAC97_UNLOCK(pDevIns, pThis);
    39813925}
    39823926
    … …  
    43724316    PAC97STATE pThis = PDMDEVINS_2_DATA(pDevIns, PAC97STATE);
    43734317
    4374     int rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsNam, ichac97IoPortNamWrite, ichac97IoPortNamRead, NULL /*pvUser*/);
     4318    int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
     4319    AssertRCReturn(rc, rc);
     4320
     4321    rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsNam, ichac97IoPortNamWrite, ichac97IoPortNamRead, NULL /*pvUser*/);
    43754322    AssertRCReturn(rc, rc);
    43764323    rc = PDMDevHlpIoPortSetUpContext(pDevIns, pThis->hIoPortsNabm, ichac97IoPortNabmWrite, ichac97IoPortNabmRead, NULL /*pvUser*/);

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

    r82255 r82323  
    13751375        Log3Func(("[SD%RU8] Scheduling timer\n", pStream->u8SD));
    13761376
    1377         TMTimerUnlock(pStream->pTimer);
    1378 
    13791377        LogFunc(("Timer set SD%RU8\n", pStream->u8SD));
    13801378        hdaR3TimerSet(pStream->pHDAState, pStream, tsTransferNext, false /* fForce */);
    1381 
    1382         TMTimerLock(pStream->pTimer, VINF_SUCCESS);
    13831379
    13841380        pStream->State.tsTransferNext = tsTransferNext;
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette