VirtualBox

Changeset 68701 in vbox for trunk


Ignore:
Timestamp:
Sep 7, 2017 4:13:53 PM (7 years ago)
Author:
vboxsync
Message:

Audio/HDA: More own locking code (needed).

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r68625 r68701  
    459459};
    460460
    461 #ifdef IN_RING3
    462 /**
    463  * Acquires the HDA lock or returns.
    464  */
    465 # define DEVHDA_LOCK(a_pThis) \
     461/**
     462 * Acquires the HDA lock.
     463 */
     464#define DEVHDA_LOCK(a_pThis) \
    466465    do { \
    467466        int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
    468467        AssertRC(rcLock); \
    469468    } while (0)
    470 #endif
     469
     470/**
     471 * Acquires the HDA lock or returns.
     472 */
     473# define DEVHDA_LOCK_RETURN(a_pThis, a_rcBusy) \
     474    do { \
     475        int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, a_rcBusy); \
     476        if (rcLock != VINF_SUCCESS) \
     477        { \
     478            AssertRC(rcLock); \
     479            return rcLock; \
     480        } \
     481    } while (0)
     482
     483/**
     484 * Acquires the HDA lock or returns.
     485 */
     486# define DEVHDA_LOCK_RETURN_VOID(a_pThis) \
     487    do { \
     488        int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
     489        if (rcLock != VINF_SUCCESS) \
     490        { \
     491            AssertRC(rcLock); \
     492            return; \
     493        } \
     494    } while (0)
    471495
    472496/**
    … …  
    479503 * Acquires the TM lock and HDA lock, returns on failure.
    480504 */
    481 #define DEVHDA_LOCK_BOTH_RETURN(a_pThis, a_rcBusy)  \
     505#define DEVHDA_LOCK_BOTH_RETURN_VOID(a_pThis) \
     506    do { \
     507        int rcLock = TMTimerLock((a_pThis)->pTimer, VERR_IGNORED); \
     508        if (rcLock != VINF_SUCCESS) \
     509        { \
     510            AssertRC(rcLock); \
     511            return; \
     512        } \
     513        rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
     514        if (rcLock != VINF_SUCCESS) \
     515        { \
     516            AssertRC(rcLock); \
     517            TMTimerUnlock((a_pThis)->pTimer); \
     518            return; \
     519        } \
     520    } while (0)
     521
     522/**
     523 * Acquires the TM lock and HDA lock, returns on failure.
     524 */
     525#define DEVHDA_LOCK_BOTH_RETURN(a_pThis, a_rcBusy) \
    482526    do { \
    483527        int rcLock = TMTimerLock((a_pThis)->pTimer, (a_rcBusy)); \
    … …  
    487531        if (rcLock != VINF_SUCCESS) \
    488532        { \
     533            AssertRC(rcLock); \
    489534            TMTimerUnlock((a_pThis)->pTimer); \
    490535            return rcLock; \
    491536        } \
    492537    } while (0)
    493 
    494538
    495539/**
    … …  
    875919    uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
    876920
     921    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_READ);
     922
    877923    *pu32Value = pThis->au32Regs[iRegMem] & g_aHdaRegMap[iReg].readable;
     924
     925    DEVHDA_UNLOCK(pThis);
    878926    return VINF_SUCCESS;
    879927}
    … …  
    881929static int hdaRegWriteU32(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
    882930{
     931    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     932
    883933    uint32_t iRegMem = g_aHdaRegMap[iReg].mem_idx;
    884934
    885935    pThis->au32Regs[iRegMem]  = (u32Value & g_aHdaRegMap[iReg].writable)
    886936                              | (pThis->au32Regs[iRegMem] & ~g_aHdaRegMap[iReg].writable);
     937    DEVHDA_UNLOCK(pThis);
    887938    return VINF_SUCCESS;
    888939}
    … …  
    894945    if (u32Value & HDA_GCTL_CRST)
    895946    {
     947        DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     948
    896949        /* Set the CRST bit to indicate that we're leaving reset mode. */
    897950        HDA_REG(pThis, GCTL) |= HDA_GCTL_CRST;
    898951        LogFunc(("Guest leaving HDA reset\n"));
     952
     953        DEVHDA_UNLOCK(pThis);
    899954    }
    900955    else
    901956    {
    902957#ifdef IN_RING3
     958        DEVHDA_LOCK(pThis);
     959
    903960        /* Enter reset state. */
    904961        LogFunc(("Guest entering HDA reset with DMA(RIRB:%s, CORB:%s)\n",
    … …  
    910967
    911968        hdaGCTLReset(pThis);
     969
     970        DEVHDA_UNLOCK(pThis);
    912971#else
    913972        return VINF_IOM_R3_MMIO_WRITE;
    … …  
    917976    if (u32Value & HDA_GCTL_FCNTRL)
    918977    {
     978        DEVHDA_LOCK(pThis);
     979
    919980        /* Flush: GSTS:1 set, see 6.2.6. */
    920981        HDA_REG(pThis, GSTS) |= HDA_GSTS_FSTS;  /* Set the flush status. */
    921982        /* DPLBASE and DPUBASE should be initialized with initial value (see 6.2.6). */
    922     }
     983
     984        DEVHDA_UNLOCK(pThis);
     985    }
     986
    923987    return VINF_SUCCESS;
    924988}
    … …  
    926990static int hdaRegWriteSTATESTS(PHDASTATE pThis, uint32_t iReg, uint32_t u32Value)
    927991{
     992    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     993
    928994    uint32_t v  = HDA_REG_IND(pThis, iReg);
    929995    uint32_t nv = u32Value & HDA_STATESTS_SCSF_MASK;
    … …  
    931997    HDA_REG(pThis, STATESTS) &= ~(v & nv); /* Write of 1 clears corresponding bit. */
    932998
     999    DEVHDA_UNLOCK(pThis);
     1000
    9331001    return VINF_SUCCESS;
    9341002}
    … …  
    9361004static int hdaRegReadLPIB(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
    9371005{
     1006    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_READ);
     1007
    9381008    const uint8_t  uSD     = HDA_SD_NUM_FROM_REG(pThis, LPIB, iReg);
    9391009    uint32_t       u32LPIB = HDA_STREAM_REG(pThis, LPIB, uSD);
    … …  
    9441014
    9451015    *pu32Value = u32LPIB;
     1016
     1017    DEVHDA_UNLOCK(pThis);
    9461018    return VINF_SUCCESS;
    9471019}
    … …  
    9901062    RT_NOREF(iReg);
    9911063
     1064    DEVHDA_LOCK(pThis);
     1065
    9921066    *pu32Value = RT_LO_U32(ASMAtomicReadU64(&pThis->u64WalClk));
    9931067
    9941068    Log3Func(("%RU32 (max @ %RU64)\n",*pu32Value, hdaWalClkGetMax(pThis)));
    9951069
     1070    DEVHDA_UNLOCK(pThis);
    9961071    return VINF_SUCCESS;
    9971072#else
    … …  
    10051080    RT_NOREF_PV(iReg);
    10061081
     1082    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     1083
    10071084    if (u32Value & HDA_CORBRP_RST)
    10081085        HDA_REG(pThis, CORBRP) = HDA_CORBRP_RST;    /* Clears the pointer. */
    … …  
    10101087        HDA_REG(pThis, CORBRP) &= ~HDA_CORBRP_RST;  /* Only CORBRP_RST bit is writable. */
    10111088
     1089    DEVHDA_UNLOCK(pThis);
    10121090    return VINF_SUCCESS;
    10131091}
    … …  
    10181096    int rc = hdaRegWriteU8(pThis, iReg, u32Value);
    10191097    AssertRC(rc);
     1098
     1099    DEVHDA_LOCK(pThis);
     1100
    10201101    if (   (uint8_t)HDA_REG(pThis, CORBWP) != (uint8_t)HDA_REG(pThis, CORBRP)
    10211102        && (HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
    10221103    {
    1023         return hdaCORBCmdProcess(pThis);
    1024     }
     1104        rc = hdaCORBCmdProcess(pThis);
     1105    }
     1106
     1107    DEVHDA_UNLOCK(pThis);
     1108
    10251109    return rc;
    10261110#else
    … …  
    10341118    RT_NOREF_PV(iReg);
    10351119
     1120    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     1121
    10361122    uint32_t v = HDA_REG(pThis, CORBSTS);
    10371123    HDA_REG(pThis, CORBSTS) &= ~(v & u32Value);
     1124
     1125    DEVHDA_UNLOCK(pThis);
     1126
    10381127    return VINF_SUCCESS;
    10391128}
    … …  
    10421131{
    10431132#ifdef IN_RING3
    1044     int rc;
    1045     rc = hdaRegWriteU16(pThis, iReg, u32Value);
    1046     if (RT_FAILURE(rc))
    1047         AssertRCReturn(rc, rc);
     1133    int rc = hdaRegWriteU16(pThis, iReg, u32Value);
     1134    AssertRCReturn(rc, rc);
     1135
     1136    DEVHDA_LOCK(pThis);
     1137
    10481138    if ((uint8_t)HDA_REG(pThis, CORBWP) == (uint8_t)HDA_REG(pThis, CORBRP))
     1139    {
     1140        DEVHDA_UNLOCK(pThis);
    10491141        return VINF_SUCCESS;
     1142    }
     1143
    10501144    if (!(HDA_REG(pThis, CORBCTL) & HDA_CORBCTL_DMA))
     1145    {
     1146        DEVHDA_UNLOCK(pThis);
    10511147        return VINF_SUCCESS;
     1148    }
     1149
    10521150    rc = hdaCORBCmdProcess(pThis);
     1151
     1152    DEVHDA_UNLOCK(pThis);
     1153
    10531154    return rc;
    10541155#else  /* !IN_RING3 */
    … …  
    10611162{
    10621163#ifdef IN_RING3
     1164    DEVHDA_LOCK(pThis);
     1165
    10631166    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, CBL, iReg));
    10641167    if (!pStream)
    … …  
    10661169        LogFunc(("[SD%RU8] Warning: Changing SDCBL on non-attached stream (0x%x)\n",
    10671170                 HDA_SD_NUM_FROM_REG(pThis, CTL, iReg), u32Value));
     1171
     1172        DEVHDA_UNLOCK(pThis);
    10681173        return hdaRegWriteU32(pThis, iReg, u32Value);
    10691174    }
    10701175
    10711176    pStream->u32CBL = u32Value;
     1177
     1178    LogFlowFunc(("[SD%RU8] CBL=%RU32\n", pStream->u8SD, u32Value));
     1179
     1180    DEVHDA_UNLOCK(pThis);
    10721181
    10731182    int rc2 = hdaRegWriteU32(pThis, iReg, u32Value);
    10741183    AssertRC(rc2);
    1075 
    1076     LogFlowFunc(("[SD%RU8] CBL=%RU32\n", pStream->u8SD, u32Value));
    10771184
    10781185    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    … …  
    10861193{
    10871194#ifdef IN_RING3
     1195    DEVHDA_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     1196
    10881197    /*
    10891198     * Some guests write too much (that is, 32-bit with the top 8 bit being junk)
    … …  
    11151224    {
    11161225        LogFunc(("[SD%RU8] Warning: Invalid stream tag %RU8 specified!\n", uSD, uTag));
     1226
     1227        DEVHDA_UNLOCK_BOTH(pThis);
    11171228        return hdaRegWriteU24(pThis, iReg, u32Value);
    11181229    }
    … …  
    12211332    }
    12221333
     1334    DEVHDA_UNLOCK_BOTH(pThis);
     1335
    12231336    int rc2 = hdaRegWriteU24(pThis, iReg, u32Value);
    12241337    AssertRC(rc2);
    … …  
    12341347{
    12351348#ifdef IN_RING3
     1349    DEVHDA_LOCK(pThis);
     1350
    12361351    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, STS, iReg));
    12371352    if (!pStream)
    … …  
    12391354        AssertMsgFailed(("[SD%RU8] Warning: Writing SDSTS on non-attached stream (0x%x)\n",
    12401355                         HDA_SD_NUM_FROM_REG(pThis, STS, iReg), u32Value));
     1356
     1357        DEVHDA_UNLOCK(pThis);
    12411358        return hdaRegWriteU16(pThis, iReg, u32Value);
    12421359    }
    … …  
    12811398    }
    12821399
     1400    DEVHDA_UNLOCK(pThis);
    12831401    return VINF_SUCCESS;
    12841402#else /* IN_RING3 */
    … …  
    12911409{
    12921410#ifdef IN_RING3
     1411    DEVHDA_LOCK(pThis);
     1412
    12931413    if (HDA_REG_IND(pThis, iReg) == u32Value) /* Value already set? */
     1414    {
     1415        DEVHDA_UNLOCK(pThis);
    12941416        return VINF_SUCCESS;
     1417    }
    12951418
    12961419    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, LVI, iReg);
    … …  
    13001423    {
    13011424        AssertMsgFailed(("[SD%RU8] Warning: Changing SDLVI on non-attached stream (0x%x)\n", uSD, u32Value));
     1425
     1426        DEVHDA_UNLOCK(pThis);
    13021427        return hdaRegWriteU16(pThis, iReg, u32Value);
    13031428    }
    … …  
    13161441    }
    13171442# endif
     1443
     1444    DEVHDA_UNLOCK(pThis);
    13181445
    13191446    int rc2 = hdaRegWriteU16(pThis, iReg, u32Value);
    … …  
    13301457{
    13311458#ifdef IN_RING3
     1459    DEVHDA_LOCK(pThis);
     1460
    13321461    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOW, iReg);
    13331462
    … …  
    13351464    {
    13361465        LogRel(("HDA: Warning: Guest tried to write read-only FIFOW to output stream #%RU8, ignoring\n", uSD));
     1466
     1467        DEVHDA_UNLOCK(pThis);
    13371468        return VINF_SUCCESS;
    13381469    }
    … …  
    13421473    {
    13431474        AssertMsgFailed(("[SD%RU8] Warning: Changing FIFOW on non-attached stream (0x%x)\n", uSD, u32Value));
     1475
     1476        DEVHDA_UNLOCK(pThis);
    13441477        return hdaRegWriteU16(pThis, iReg, u32Value);
    13451478    }
    … …  
    13671500        LogFunc(("[SD%RU8] Updating FIFOW to %RU32 bytes\n", uSD, pStream->u16FIFOW));
    13681501
     1502        DEVHDA_UNLOCK(pThis);
     1503
    13691504        int rc2 = hdaRegWriteU16(pThis, iReg, u32FIFOW);
    13701505        AssertRC(rc2);
    13711506    }
    13721507
     1508    DEVHDA_UNLOCK(pThis);
    13731509    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    13741510#else  /* !IN_RING3 */
    … …  
    13841520{
    13851521#ifdef IN_RING3
     1522    DEVHDA_LOCK(pThis);
     1523
    13861524    uint8_t uSD = HDA_SD_NUM_FROM_REG(pThis, FIFOS, iReg);
    13871525
    … …  
    13891527    {
    13901528        LogRel(("HDA: Warning: Guest tried to write read-only FIFOS to input stream #%RU8, ignoring\n", uSD));
     1529
     1530        DEVHDA_UNLOCK(pThis);
    13911531        return VINF_SUCCESS;
    13921532    }
    … …  
    13961536    {
    13971537        AssertMsgFailed(("[SD%RU8] Warning: Changing FIFOS on non-attached stream (0x%x)\n", uSD, u32Value));
     1538
     1539        DEVHDA_UNLOCK(pThis);
    13981540        return hdaRegWriteU16(pThis, iReg, u32Value);
    13991541    }
    … …  
    14251567        LogFunc(("[SD%RU8] Updating FIFOS to %RU32 bytes\n", uSD, pStream->u16FIFOS));
    14261568
     1569        DEVHDA_UNLOCK(pThis);
     1570
    14271571        int rc2 = hdaRegWriteU16(pThis, iReg, u32FIFOS);
    14281572        AssertRC(rc2);
    14291573    }
     1574    else
     1575        DEVHDA_UNLOCK(pThis);
    14301576
    14311577    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    … …  
    16761822{
    16771823#ifdef IN_RING3
     1824    DEVHDA_LOCK(pThis);
     1825
    16781826    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, HDA_SD_NUM_FROM_REG(pThis, FMT, iReg));
    16791827    if (!pStream)
    … …  
    17041852# endif
    17051853    }
     1854
     1855    DEVHDA_UNLOCK(pThis);
    17061856    return VINF_SUCCESS; /* Never return failure. */
    17071857#else /* !IN_RING3 */
    … …  
    17181868    AssertRC(rc2);
    17191869
     1870    DEVHDA_LOCK(pThis);
     1871
    17201872    PHDASTREAM pStream = hdaGetStreamFromSD(pThis, uSD);
    17211873    if (!pStream)
     1874    {
     1875        DEVHDA_UNLOCK(pThis);
    17221876        return VINF_SUCCESS;
     1877    }
    17231878
    17241879    /* Update BDL base. */
    … …  
    17371892
    17381893    LogFlowFunc(("[SD%RU8] BDLBase=0x%x\n", pStream->u8SD, pStream->u64BDLBase));
     1894
     1895    DEVHDA_UNLOCK(pThis);
    17391896
    17401897    return VINF_SUCCESS; /* Always return success to the MMIO handler. */
    … …  
    17571914static int hdaRegReadIRS(PHDASTATE pThis, uint32_t iReg, uint32_t *pu32Value)
    17581915{
     1916    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_READ);
     1917
    17591918    /* regarding 3.4.3 we should mark IRS as busy in case CORB is active */
    17601919    if (   HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP)
    … …  
    17641923    }
    17651924
     1925    DEVHDA_UNLOCK(pThis);
     1926
    17661927    return hdaRegReadU32(pThis, iReg, pu32Value);
    17671928}
    … …  
    17701931{
    17711932    RT_NOREF_PV(iReg);
     1933
     1934    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    17721935
    17731936    /*
    … …  
    17831946        if (HDA_REG(pThis, CORBWP) != HDA_REG(pThis, CORBRP))
    17841947        {
     1948            DEVHDA_UNLOCK(pThis);
     1949
    17851950            /*
    17861951             * 3.4.3: Defines behavior of immediate Command status register.
    … …  
    18021967        /** @todo r=michaln We just set the IRS value, why are we clearing unset bits? */
    18031968        HDA_REG(pThis, IRS) &= ~HDA_IRS_ICB;    /* busy is clear */
     1969
     1970        DEVHDA_UNLOCK(pThis);
    18041971        return VINF_SUCCESS;
    18051972#else  /* !IN_RING3 */
     1973        DEVHDA_UNLOCK(pThis);
    18061974        return VINF_IOM_R3_MMIO_WRITE;
    18071975#endif /* !IN_RING3 */
    … …  
    18121980     */
    18131981    HDA_REG(pThis, IRS) &= ~(u32Value & HDA_IRS_IRV);
     1982
     1983    DEVHDA_UNLOCK(pThis);
    18141984    return VINF_SUCCESS;
    18151985}
    … …  
    18181988{
    18191989    RT_NOREF_PV(iReg);
     1990
     1991    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    18201992
    18211993    if (u32Value & HDA_RIRBWP_RST)
    18221994        HDA_REG(pThis, RIRBWP) = 0;
     1995
     1996    DEVHDA_UNLOCK(pThis);
    18231997
    18241998    /* The remaining bits are O, see 6.2.22. */
    … …  
    18322006    if (RT_FAILURE(rc))
    18332007        AssertRCReturn(rc, rc);
     2008
     2009    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    18342010
    18352011    switch(iReg)
    … …  
    18712047    LogFunc(("CORB base:%llx RIRB base: %llx DP base: %llx\n",
    18722048             pThis->u64CORBBase, pThis->u64RIRBBase, pThis->u64DPBase));
     2049
     2050    DEVHDA_UNLOCK(pThis);
    18732051    return rc;
    18742052}
    … …  
    18772055{
    18782056    RT_NOREF_PV(iReg);
     2057
     2058    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    18792059
    18802060    uint8_t v = HDA_REG(pThis, RIRBSTS);
    18812061    HDA_REG(pThis, RIRBSTS) &= ~(v & u32Value);
     2062
     2063    DEVHDA_UNLOCK(pThis);
    18822064
    18832065#ifndef DEBUG
    … …  
    23072489#ifndef VBOX_WITH_AUDIO_HDA_CALLBACKS
    23082490/**
     2491 * Starts the internal audio device timer.
     2492 *
     2493 * @param   pThis               HDA state.
     2494 */
     2495static int hdaTimerStart(PHDASTATE pThis)
     2496{
     2497    LogFlowFuncEnter();
     2498
     2499    DEVHDA_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     2500
     2501    AssertPtr(pThis->pTimer);
     2502
     2503    if (!pThis->fTimerActive)
     2504    {
     2505        LogRel2(("HDA: Starting transfers\n"));
     2506
     2507        pThis->fTimerActive  = true;
     2508        pThis->tsTimerExpire = TMTimerGet(pThis->pTimer) + pThis->cTimerTicks; /* Update current time timestamp. */
     2509
     2510        /* Start transfers. */
     2511        hdaTimerMain(pThis);
     2512    }
     2513
     2514    DEVHDA_UNLOCK_BOTH(pThis);
     2515
     2516    return VINF_SUCCESS;
     2517}
     2518
     2519/**
    23092520 * Starts the internal audio device timer (if not started yet).
    23102521 *
    … …  
    23222533    /* Only start the timer at the first active stream. */
    23232534    if (pThis->cStreamsActive == 1)
    2324     {
    2325         LogRel2(("HDA: Starting transfers\n"));
    2326 
    2327         /* Set timer flag. */
    2328         ASMAtomicXchgBool(&pThis->fTimerActive, true);
    2329 
    2330         DEVHDA_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    2331 
    2332         /* Update current time timestamp. */
    2333         pThis->tsTimerExpire = TMTimerGet(pThis->pTimer) + pThis->cTimerTicks;
    2334 
    2335         /* Start transfers. */
    2336         hdaTimerMain(pThis);
    2337 
    2338         DEVHDA_UNLOCK_BOTH(pThis);
    2339     }
     2535        return hdaTimerStart(pThis);
    23402536
    23412537    return VINF_SUCCESS;
    … …  
    23512547    LogFlowFuncEnter();
    23522548
    2353     if (!ASMAtomicReadBool(&pThis->fTimerActive))
     2549    if (!pThis->pTimer) /* Only can happen on device construction time, so no locking needed here. */
    23542550        return VINF_SUCCESS;
    23552551
    2356     LogRel2(("HDA: Stopping transfers ...\n"));
    2357 
    2358     /* Set timer flag. */
    2359     ASMAtomicXchgBool(&pThis->fTimerActive, false);
    2360 
    2361     if (pThis->pTimer)
    2362     {
    2363         DEVHDA_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     2552    DEVHDA_LOCK_BOTH_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     2553
     2554    if (pThis->fTimerActive)
     2555    {
     2556        LogRel2(("HDA: Stopping transfers ...\n"));
     2557
     2558        pThis->fTimerActive = false;
    23642559
    23652560        TMTimerStop(pThis->pTimer);
    2366 
    2367         DEVHDA_UNLOCK_BOTH(pThis);
    2368     }
     2561    }
     2562
     2563    DEVHDA_UNLOCK_BOTH(pThis);
    23692564
    23702565    return VINF_SUCCESS;
    … …  
    24082603    STAM_PROFILE_START(&pThis->StatTimer, a);
    24092604
    2410     DEVHDA_LOCK(pThis);
     2605    DEVHDA_LOCK_BOTH_RETURN_VOID(pThis);
    24112606
    24122607    /* Flag indicating whether to kick the timer again for a
    … …  
    24422637        LogRel2(("HDA: Stopped transfers\n"));
    24432638
    2444     DEVHDA_UNLOCK(pThis);
     2639    DEVHDA_UNLOCK_BOTH(pThis);
    24452640
    24462641    STAM_PROFILE_STOP(&pThis->StatTimer, a);
    … …  
    28163011    Assert(cb == 4); Assert((offReg & 3) == 0);
    28173012
     3013    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_READ);
     3014
    28183015    if (!(HDA_REG(pThis, GCTL) & HDA_GCTL_CRST) && idxRegDsc != HDA_REG_GCTL)
    28193016        LogFunc(("Access to registers except GCTL is blocked while reset\n"));
    … …  
    28243021    if (idxRegDsc != -1)
    28253022    {
     3023        /* Leave lock before calling read function. */
     3024        DEVHDA_UNLOCK(pThis);
     3025
    28263026        /* ASSUMES gapless DWORD at end of map. */
    28273027        if (g_aHdaRegMap[idxRegDsc].size == 4)
    … …  
    28653065    else
    28663066    {
     3067        DEVHDA_UNLOCK(pThis);
     3068
    28673069        rc = VINF_IOM_MMIO_UNUSED_FF;
    28683070        Log3Func(("\tHole at %x is accessed for read\n", offReg));
    … …  
    28863088DECLINLINE(int) hdaWriteReg(PHDASTATE pThis, int idxRegDsc, uint32_t u32Value, char const *pszLog)
    28873089{
     3090    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_READ);
     3091
    28883092    if (!(HDA_REG(pThis, GCTL) & HDA_GCTL_CRST) && idxRegDsc != HDA_REG_GCTL)
    28893093    {
    … …  
    28913095        LogRel2(("HDA: Warning: Access to register %s is blocked while controller is in reset mode\n",
    28923096                 g_aHdaRegMap[idxRegDsc].abbrev));
     3097
     3098        DEVHDA_UNLOCK(pThis);
    28933099        return VINF_SUCCESS;
    28943100    }
    … …  
    29163122            LogRel2(("HDA: Warning: Access to register %s is blocked while the stream's RUN bit is set\n",
    29173123                     g_aHdaRegMap[idxRegDsc].abbrev));
     3124
     3125            DEVHDA_UNLOCK(pThis);
    29183126            return VINF_SUCCESS;
    29193127        }
    29203128    }
     3129
     3130    /* Leave the lock before calling write function. */
     3131    DEVHDA_UNLOCK(pThis);
    29213132
    29223133#ifdef LOG_ENABLED
    … …  
    41204331
    41214332    LogFlowFuncEnter();
     4333
     4334    DEVHDA_LOCK_RETURN_VOID(pThis);
     4335
    41224336     /*
    41234337     * 18.2.6,7 defines that values of this registers might be cleared on power on/reset
    … …  
    41324346     */
    41334347    HDA_REG(pThis, GCTL)    = HDA_GCTL_CRST;
     4348
     4349    DEVHDA_UNLOCK(pThis);
    41344350}
    41354351
    … …  
    41404356{
    41414357    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
     4358
     4359    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
    41424360
    41434361    PHDADRIVER pDrv;
    … …  
    41664384    for (uint8_t i = 0; i < HDA_MAX_STREAMS; i++)
    41674385        hdaStreamDestroy(&pThis->aStreams[i]);
     4386
     4387    DEVHDA_UNLOCK(pThis);
    41684388
    41694389    return VINF_SUCCESS;
    … …  
    42604480static DECLCALLBACK(int) hdaAttach(PPDMDEVINS pDevIns, unsigned uLUN, uint32_t fFlags)
    42614481{
    4262     return hdaAttachInternal(pDevIns, NULL /* pDrv */, uLUN, fFlags);
     4482    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
     4483
     4484    DEVHDA_LOCK_RETURN(pThis, VINF_IOM_R3_MMIO_WRITE);
     4485
     4486    int rc = hdaAttachInternal(pDevIns, NULL /* pDrv */, uLUN, fFlags);
     4487
     4488    DEVHDA_UNLOCK(pThis);
     4489
     4490    return rc;
    42634491}
    42644492
    … …  
    42774505{
    42784506    PHDASTATE pThis = PDMINS_2_DATA(pDevIns, PHDASTATE);
     4507
     4508    DEVHDA_LOCK_RETURN_VOID(pThis);
    42794509
    42804510    LogRel2(("HDA: Powering off ...\n"));
    … …  
    42934523        pThis->pMixer = NULL;
    42944524    }
     4525
     4526    DEVHDA_UNLOCK(pThis);
    42954527}
    42964528
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