VirtualBox

Changeset 32860 in vbox


Ignore:
Timestamp:
Oct 1, 2010 11:30:38 AM (14 years ago)
Author:
vboxsync
Message:

PCI: MSI per-vector masking, saved states

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/msi.h

    r32820 r32860  
    9696#define VBOX_MSI_CAP_PENDING_BITS_64          0x14
    9797
    98 /* At the moment, we implement MSI without per-vector masking */
    99 #define VBOX_MSI_CAP_SIZE_32                  0x0a
    100 #define VBOX_MSI_CAP_SIZE_64                  0x0c
     98/* We implement MSI with per-vector masking */
     99#define VBOX_MSI_CAP_SIZE_32                  0x14
     100#define VBOX_MSI_CAP_SIZE_64                  0x18
    101101
    102102/**

  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r32820 r32860  
    13811381        { 0x20, 2, 1, 2, "MEMORY_BASE" },       // fWritable = ??
    13821382        { 0x22, 2, 1, 2, "MEMORY_LIMIT" },      // fWritable = ??
    1383         { 0x24, 4, 1, 1, "BASE_ADDRESS_4" },
     1383        { 0x24, 4, 1, 1, "BASE_ADDRESS_5" },
    13841384        { 0x24, 2, 1, 2, "PREF_MEMORY_BASE" },  // fWritable = ??
    13851385        { 0x26, 2, 1, 2, "PREF_MEMORY_LIMIT" }, // fWritable = ??

  • trunk/src/VBox/Devices/Bus/DevPciIch9.cpp

    r32820 r32860  
    134134 * Saved state version of the ICH9 PCI bus device.
    135135 */
    136 #define VBOX_ICH9PCI_SAVED_STATE_VERSION 1
     136#define VBOX_ICH9PCI_SAVED_STATE_VERSION_NOMSI 1
     137#define VBOX_ICH9PCI_SAVED_STATE_VERSION_MSI   2
     138#define VBOX_ICH9PCI_SAVED_STATE_VERSION_CURRENT VBOX_ICH9PCI_SAVED_STATE_VERSION_MSI
    137139
    138140/** Converts a bus instance pointer to a device instance pointer. */
    … …  
    180182static int ich9pciRegisterInternal(PPCIBUS pBus, int iDev, PPCIDEVICE pPciDev, const char *pszName);
    181183static void ich9pciUpdateMappings(PCIDevice *pDev);
    182 static DECLCALLBACK(uint32_t) ich9pciConfigRead(PCIDevice *aDev, uint32_t u32Address, unsigned len);
     184static DECLCALLBACK(uint32_t) ich9pciConfigReadDev(PCIDevice *aDev, uint32_t u32Address, unsigned len);
    183185DECLINLINE(PPCIDEVICE) ich9pciFindBridge(PPCIBUS pBus, uint8_t iBus);
    184186static void ich9pciBiosInitDevice(PPCIGLOBALS pGlobals, uint8_t uBus, uint8_t uDevFn, uint8_t cBridgeDepth, uint8_t *paBridgePositions);
    … …  
    409411            R3PTRTYPE(PCIDevice *) aDev = pGlobals->aPciBus.apDevices[pPciAddr->iDeviceFunc];
    410412            *pu32 = aDev->Int.s.pfnConfigRead(aDev, pPciAddr->iRegister, len);
    411             Log(("ich9pciConfigRead: %s: addr=%02x val=%08x len=%d\n", aDev->name, pPciAddr->iRegister, *pu32, len));
     413            Log(("ich9pciDataReadAddr: %s: addr=%02x val=%08x len=%d\n", aDev->name, pPciAddr->iRegister, *pu32, len));
    412414#else
    413415            return VINF_IOM_HC_IOPORT_READ;
    … …  
    529531    {
    530532        Log2(("Raise a MSI interrupt: %d\n", iIrq));
    531         MSINotify(pGlobals->aPciBus.CTX_SUFF(pDevIns), pPciDev, iIrq);
     533        /* We only trigger MSI on level up, as technically it's matching flip-flop best (maybe even assert that level == PDM_IRQ_LEVEL_FLIP_FLOP) */
     534        if ((iLevel & PDM_IRQ_LEVEL_HIGH) != 0)
     535            MSINotify(pGlobals->aPciBus.CTX_SUFF(pDevIns), pPciDev, iIrq);
    532536        return;
    533537    }
    … …  
    673677            {
    674678                /* IO access allowed */
    675                 uNew = ich9pciConfigRead(pDev, uConfigReg, 4);
     679                uNew = ich9pciConfigReadDev(pDev, uConfigReg, 4);
    676680                uNew &= ~(iRegionSize - 1);
    677681                uLast = uNew + iRegionSize - 1;
    … …  
    687691            if (iCmd & PCI_COMMAND_MEMACCESS)
    688692            {
    689                 uNew = ich9pciConfigRead(pDev, uConfigReg, 4);
     693                uNew = ich9pciConfigReadDev(pDev, uConfigReg, 4);
    690694                /* the ROM slot has a specific enable bit */
    691695                if (iRegion == PCI_ROM_SLOT && !(uNew & 1))
    … …  
    885889            SSMR3PutMem(pSSM, pDev->config, sizeof(pDev->config));
    886890
    887             /* IRQ pin state */
    888             int rc = SSMR3PutS32(pSSM, pDev->Int.s.uIrqPinState);
     891            /* Device flags */
     892            int rc = SSMR3PutU32(pSSM, pDev->Int.s.uFlags);
    889893            if (RT_FAILURE(rc))
    890894                return rc;
     895
     896            /* IRQ pin state */
     897            rc = SSMR3PutS32(pSSM, pDev->Int.s.uIrqPinState);
     898            if (RT_FAILURE(rc))
     899                return rc;
     900
     901            /* MSI info */
     902            rc = SSMR3PutU8(pSSM, pDev->Int.s.u8MsiCapOffset);
     903            if (RT_FAILURE(rc))
     904                return rc;
     905            rc = SSMR3PutU8(pSSM, pDev->Int.s.u8MsiCapSize);
     906            if (RT_FAILURE(rc))
     907                return rc;
     908
     909            /* MSI-X info */
     910            rc = SSMR3PutU8(pSSM, pDev->Int.s.u8MsixCapOffset);
     911            if (RT_FAILURE(rc))
     912                return rc;
     913            rc = SSMR3PutU8(pSSM, pDev->Int.s.u8MsixCapSize);
     914            if (RT_FAILURE(rc))
     915                return rc;
    891916        }
    892917    }
    … …  
    896921static DECLCALLBACK(int) ich9pciR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    897922{
    898     PPCIBUS pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
    899     return ich9pciR3CommonSaveExec(pThis, pSSM);
     923    PPCIGLOBALS pThis = PDMINS_2_DATA(pDevIns, PPCIGLOBALS);
     924
     925    /*
     926     * Bus state data.
     927     */
     928    SSMR3PutU32(pSSM, pThis->uConfigReg);
     929
     930    /*
     931     * Save IRQ states.
     932     */
     933    for (int i = 0; i < PCI_APIC_IRQ_PINS; i++)
     934        SSMR3PutU32(pSSM, pThis->uaPciApicIrqLevels[i]);
     935
     936    SSMR3PutU32(pSSM, ~0);        /* separator */
     937
     938    return ich9pciR3CommonSaveExec(&pThis->aPciBus, pSSM);
    900939}
    901940
    … …  
    9971036        { VBOX_PCI_CLASS_PROG, 1, 0, 3, "CLASS_PROG" },
    9981037        { VBOX_PCI_CLASS_SUB, 1, 0, 3, "CLASS_SUB" },
    999         { VBOX_PCI_CLASS_DEVICE, 1, 0, 3, "CLASS_BASE" },
     1038        { VBOX_PCI_CLASS_BASE, 1, 0, 3, "CLASS_BASE" },
    10001039        { VBOX_PCI_CACHE_LINE_SIZE, 1, 1, 3, "CACHE_LINE_SIZE" },
    10011040        { VBOX_PCI_LATENCY_TIMER, 1, 1, 3, "LATENCY_TIMER" },
    … …  
    10161055        { VBOX_PCI_MEMORY_BASE, 2, 1, 2, "MEMORY_BASE" },       // fWritable = ??
    10171056        { VBOX_PCI_MEMORY_LIMIT, 2, 1, 2, "MEMORY_LIMIT" },      // fWritable = ??
    1018         { VBOX_PCI_BASE_ADDRESS_4, 4, 1, 1, "BASE_ADDRESS_4" },
     1057        { VBOX_PCI_BASE_ADDRESS_5, 4, 1, 1, "BASE_ADDRESS_5" },
    10191058        { VBOX_PCI_PREF_MEMORY_BASE, 2, 1, 2, "PREF_MEMORY_BASE" },  // fWritable = ??
    10201059        { VBOX_PCI_PREF_MEMORY_LIMIT, 2, 1, 2, "PREF_MEMORY_LIMIT" }, // fWritable = ??
    … …  
    10341073        { VBOX_PCI_MIN_GNT, 1, 0, 1, "MIN_GNT" },
    10351074        { VBOX_PCI_BRIDGE_CONTROL, 2, 1, 2, "BRIDGE_CONTROL" },    // fWritable = !?
    1036         { VBOX_PCI_MAX_LAT, 1, 0, 3, "MAX_LAT" },           // fBridge=!?
     1075        { VBOX_PCI_MAX_LAT, 1, 0, 1, "MAX_LAT" },
    10371076        /* The COMMAND register must come last as it requires the *ADDRESS*
    10381077           registers to be restored before we pretent to change it from 0 to
    … …  
    12061245
    12071246        /* get the data */
     1247        DevTmp.Int.s.uFlags = 0;
     1248        DevTmp.Int.s.u8MsiCapOffset = 0;
     1249        DevTmp.Int.s.u8MsiCapSize = 0;
     1250        DevTmp.Int.s.u8MsixCapOffset = 0;
     1251        DevTmp.Int.s.u8MsixCapSize = 0;
    12081252        DevTmp.Int.s.uIrqPinState = ~0; /* Invalid value in case we have an older saved state to force a state change in pciSetIrq. */
    12091253        SSMR3GetMem(pSSM, DevTmp.config, sizeof(DevTmp.config));
    12101254
     1255        rc = SSMR3GetU32(pSSM, &DevTmp.Int.s.uFlags);
     1256        if (RT_FAILURE(rc))
     1257            return rc;
     1258
    12111259        rc = SSMR3GetS32(pSSM, &DevTmp.Int.s.uIrqPinState);
     1260        if (RT_FAILURE(rc))
     1261            return rc;
     1262
     1263        rc = SSMR3GetU8(pSSM, &DevTmp.Int.s.u8MsiCapOffset);
     1264        if (RT_FAILURE(rc))
     1265            return rc;
     1266
     1267        rc = SSMR3GetU8(pSSM, &DevTmp.Int.s.u8MsiCapSize);
     1268        if (RT_FAILURE(rc))
     1269            return rc;
     1270
     1271        rc = SSMR3GetU8(pSSM, &DevTmp.Int.s.u8MsixCapOffset);
     1272        if (RT_FAILURE(rc))
     1273            return rc;
     1274
     1275        rc = SSMR3GetU8(pSSM, &DevTmp.Int.s.u8MsixCapSize);
    12121276        if (RT_FAILURE(rc))
    12131277            return rc;
    … …  
    12551319static DECLCALLBACK(int) ich9pciR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    12561320{
     1321    PPCIGLOBALS pThis = PDMINS_2_DATA(pDevIns, PPCIGLOBALS);
     1322    PPCIBUS     pBus  = &pThis->aPciBus;
     1323    uint32_t    u32;
     1324    int         rc;
     1325
     1326    /* We ignore this version as there's no saved state with it anyway */
     1327    if (uVersion == VBOX_ICH9PCI_SAVED_STATE_VERSION_NOMSI)
     1328        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
     1329    if (uVersion > VBOX_ICH9PCI_SAVED_STATE_VERSION_MSI)
     1330        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
     1331
     1332    /*
     1333     * Bus state data.
     1334     */
     1335    SSMR3GetU32(pSSM, &pThis->uConfigReg);
     1336
     1337    /*
     1338     * Load IRQ states.
     1339     */
     1340    for (int i = 0; i < PCI_APIC_IRQ_PINS; i++)
     1341        SSMR3GetU32(pSSM, (uint32_t*)&pThis->uaPciApicIrqLevels[i]);
     1342
     1343    /* separator */
     1344    rc = SSMR3GetU32(pSSM, &u32);
     1345    if (RT_FAILURE(rc))
     1346        return rc;
     1347    if (u32 != (uint32_t)~0)
     1348        AssertMsgFailedReturn(("u32=%#x\n", u32), rc);
     1349
     1350    return ich9pciR3CommonLoadExec(pBus, pSSM, uVersion, uPass);
     1351}
     1352
     1353static DECLCALLBACK(int) ich9pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
     1354{
    12571355    PPCIBUS pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
    1258     if (uVersion > VBOX_ICH9PCI_SAVED_STATE_VERSION)
    1259         return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    1260     return ich9pciR3CommonLoadExec(pThis, pSSM, uVersion, uPass);
    1261 }
    1262 
    1263 static DECLCALLBACK(int) ich9pcibridgeR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    1264 {
    1265     PPCIBUS pThis = PDMINS_2_DATA(pDevIns, PPCIBUS);
    1266     if (uVersion > VBOX_ICH9PCI_SAVED_STATE_VERSION)
     1356    if (uVersion > VBOX_ICH9PCI_SAVED_STATE_VERSION_MSI)
    12671357        return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
    12681358    return ich9pciR3CommonLoadExec(pThis, pSSM, uVersion, uPass);
    … …  
    15841674}
    15851675
    1586 static DECLCALLBACK(uint32_t) ich9pciConfigRead(PCIDevice *aDev, uint32_t u32Address, unsigned len)
     1676static DECLCALLBACK(uint32_t) ich9pciConfigReadDev(PCIDevice *aDev, uint32_t u32Address, unsigned len)
    15871677{
    15881678    if ((u32Address + len) > 256 && (u32Address + len) < 4096)
    … …  
    15961686       )
    15971687    {
    1598         return MSIPciConfigRead(aDev, u32Address, len);
     1688        return MSIPciConfigRead(aDev->Int.s.CTX_SUFF(pBus)->CTX_SUFF(pDevIns), aDev, u32Address, len);
    15991689    }
    16001690
    … …  
    16181708 * registers and their writability policy.
    16191709 */
    1620 static DECLCALLBACK(void) ich9pciConfigWrite(PCIDevice *aDev, uint32_t u32Address,
    1621                                              uint32_t val, unsigned len)
     1710static DECLCALLBACK(void) ich9pciConfigWriteDev(PCIDevice *aDev, uint32_t u32Address,
     1711                                                uint32_t val, unsigned len)
    16221712{
    16231713    if ((u32Address + len) > 256 && (u32Address + len) < 4096)
    … …  
    16331723       )
    16341724    {
    1635         MSIPciConfigWrite(aDev, u32Address, val, len);
     1725        MSIPciConfigWrite(aDev->Int.s.CTX_SUFF(pBus)->CTX_SUFF(pDevIns), aDev, u32Address, val, len);
    16361726        return;
    16371727    }
    … …  
    19051995    pPciDev->Int.s.pBusR0           = MMHyperR3ToR0(PDMDevHlpGetVM(pBus->CTX_SUFF(pDevIns)), pBus);
    19061996    pPciDev->Int.s.pBusRC           = MMHyperR3ToRC(PDMDevHlpGetVM(pBus->CTX_SUFF(pDevIns)), pBus);
    1907     pPciDev->Int.s.pfnConfigRead    = ich9pciConfigRead;
    1908     pPciDev->Int.s.pfnConfigWrite   = ich9pciConfigWrite;
     1997    pPciDev->Int.s.pfnConfigRead    = ich9pciConfigReadDev;
     1998    pPciDev->Int.s.pfnConfigWrite   = ich9pciConfigWriteDev;
    19091999    pBus->apDevices[iDev]           = pPciDev;
    19102000    if (PCIIsPci2PciBridge(pPciDev))
    … …  
    21452235    }
    21462236
     2237    rc = PDMDevHlpSSMRegisterEx(pDevIns, VBOX_ICH9PCI_SAVED_STATE_VERSION_CURRENT,
     2238                                sizeof(*pBus) + 16*128, "pgm",
     2239                                NULL, NULL, NULL,
     2240                                NULL, ich9pciR3SaveExec, NULL,
     2241                                NULL, ich9pciR3LoadExec, NULL);
     2242    if (RT_FAILURE(rc))
     2243        return rc;
     2244
    21472245
    21482246    /** @todo: other chipset devices shall be registered too */
    … …  
    22862384     * to make changes easier.
    22872385     */
    2288     rc = PDMDevHlpSSMRegisterEx(pDevIns, VBOX_ICH9PCI_SAVED_STATE_VERSION, sizeof(*pBus) + 16*128, "pgm",
     2386    rc = PDMDevHlpSSMRegisterEx(pDevIns, VBOX_ICH9PCI_SAVED_STATE_VERSION_CURRENT,
     2387                                sizeof(*pBus) + 16*128,
     2388                                "pgm" /* before */,
    22892389                                NULL, NULL, NULL,
    22902390                                NULL, ich9pcibridgeR3SaveExec, NULL,

  • trunk/src/VBox/Devices/Bus/MsiCommon.cpp

    r32822 r32860  
    3535}
    3636
     37DECLINLINE(uint32_t*) msiGetMaskBits(PPCIDEVICE pDev)
     38{
     39    uint8_t iOff = msiIs64Bit(pDev) ? VBOX_MSI_CAP_MASK_BITS_64 : VBOX_MSI_CAP_MASK_BITS_32;
     40    iOff += pDev->Int.s.u8MsiCapOffset;
     41    return (uint32_t*)(pDev->config + iOff);
     42}
     43
     44DECLINLINE(uint32_t*) msiGetPendingBits(PPCIDEVICE pDev)
     45{
     46    uint8_t iOff = msiIs64Bit(pDev) ? VBOX_MSI_CAP_PENDING_BITS_64 : VBOX_MSI_CAP_PENDING_BITS_32;
     47    iOff += pDev->Int.s.u8MsiCapOffset;
     48    return (uint32_t*)(pDev->config + iOff);
     49}
     50
    3751DECLINLINE(bool) msiIsEnabled(PPCIDEVICE pDev)
    3852{
    … …  
    7084}
    7185
    72 void     MSIPciConfigWrite(PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len)
     86DECLINLINE(bool) msiBitJustCleared(uint32_t u32OldValue,
     87                                   uint32_t u32NewValue,
     88                                   uint32_t u32Mask)
     89{
     90    return (!!(u32OldValue & u32Mask) && !(u32NewValue & u32Mask));
     91}
     92
     93
     94void     MSIPciConfigWrite(PPDMDEVINS pDevIns, PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len)
    7395{
    7496    int32_t iOff = u32Address - pDev->Int.s.u8MsiCapOffset;
    … …  
    78100
    79101    uint32_t uAddr = u32Address;
     102    bool f64Bit = msiIs64Bit(pDev);
     103
    80104    for (uint32_t i = 0; i < len; i++)
    81105    {
    82         switch (i + iOff)
     106        uint32_t reg = i + iOff;
     107        switch (reg)
    83108        {
    84109            case 0: /* Capability ID, ro */
    85110            case 1: /* Next pointer,  ro */
    86111                break;
    87             case 2:
     112            case VBOX_MSI_CAP_MESSAGE_CONTROL:
    88113                /* don't change read-only bits: 1-3,7 */
    89114                val &= UINT32_C(~0x8e);
    90115                pDev->config[uAddr] &= ~val;
    91116                break;
    92             case 3:
     117            case VBOX_MSI_CAP_MESSAGE_CONTROL + 1:
    93118                /* don't change read-only bit 8, and reserved 9-15 */
    94119                break;
    95120            default:
    96                 pDev->config[uAddr] = val;
     121                if (pDev->config[uAddr] != val)
     122                {
     123                    int32_t maskUpdated = -1;
     124
     125                    /* If we're enabling masked vector, and have pending messages
     126                       for this vector, we have to send this message now */
     127                    if (    !f64Bit
     128                         && (reg >= VBOX_MSI_CAP_MASK_BITS_32)
     129                         && (reg < VBOX_MSI_CAP_MASK_BITS_32 + 4)
     130                        )
     131                    {
     132                        maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_32;
     133                    }
     134                    if (    f64Bit
     135                         && (reg >= VBOX_MSI_CAP_MASK_BITS_64)
     136                         && (reg < VBOX_MSI_CAP_MASK_BITS_64 + 4)
     137                       )
     138                    {
     139                        maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_64;
     140                    }
     141
     142                    if (maskUpdated != -1)
     143                    {
     144                        for (int iBitNum = 0; i<8; i++)
     145                        {
     146                            int32_t iBit = 1 << iBitNum;
     147                            if (msiBitJustCleared(pDev->config[uAddr], val, iBit))
     148                            {
     149                                /* To ensure that we're no longer masked */
     150                                pDev->config[uAddr] &= ~iBit;
     151                                MSINotify(pDevIns, pDev, maskUpdated*8 + iBitNum);
     152                            }
     153                        }
     154                    }
     155
     156                    pDev->config[uAddr] = val;
     157                }
    97158        }
    98159        uAddr++;
    … …  
    101162}
    102163
    103 uint32_t MSIPciConfigRead (PPCIDEVICE pDev, uint32_t u32Address, unsigned len)
     164uint32_t MSIPciConfigRead (PPDMDEVINS pDevIns, PPCIDEVICE pDev, uint32_t u32Address, unsigned len)
    104165{
    105166    int32_t iOff = u32Address - pDev->Int.s.u8MsiCapOffset;
    106167
    107     Log2(("MSIPciConfigRead: %d (%d)\n", iOff, len));
    108 
    109168    Assert(iOff >= 0 && (PCIIsMsiCapable(pDev) && iOff < pDev->Int.s.u8MsiCapSize));
     169    uint32_t rv = 0;
    110170
    111171    switch (len)
    112172    {
    113173        case 1:
    114             return PCIDevGetByte(pDev, u32Address);
     174            rv = PCIDevGetByte(pDev, u32Address);
     175            break;
    115176        case 2:
    116             return PCIDevGetWord(pDev, u32Address);
     177            rv = PCIDevGetWord(pDev, u32Address);
     178            break;
     179        case 4:
     180            rv = PCIDevGetDWord(pDev, u32Address);
     181            break;
    117182        default:
    118         case 4:
    119             return PCIDevGetDWord(pDev, u32Address);
    120     }
     183            Assert(false);
     184    }
     185
     186    Log2(("MSIPciConfigRead: %d (%d) -> %x\n", iOff, len, rv));
     187
     188    return rv;
    121189}
    122190
    … …  
    137205
    138206    bool f64bit = (iMsiFlags & VBOX_PCI_MSI_FLAGS_64BIT) != 0;
     207    /* We always support per-vector masking */
     208    iMsiFlags |= VBOX_PCI_MSI_FLAGS_MASKBIT;
    139209
    140210    pDev->Int.s.u8MsiCapOffset = iCapOffset;
    … …  
    162232    AssertMsg(msiIsEnabled(pDev), ("Must be enabled to use that"));
    163233
     234    uint32_t   uMask = *msiGetMaskBits(pDev);
     235    uint32_t*  upPending = msiGetPendingBits(pDev);
     236
     237    if ((uMask & (1<<iVector)) != 0)
     238    {
     239        *upPending |= (1<<iVector);
     240        return;
     241    }
     242
    164243    RTGCPHYS   GCAddr = msiGetMsiAddress(pDev);
    165244    uint32_t   u32Value = msiGetMsiData(pDev, iVector);
    166245
     246    *upPending &= ~(1<<iVector);
     247
    167248    PDMDevHlpPhysWrite(pDevIns, GCAddr, &u32Value, sizeof(u32Value));
    168249}

  • trunk/src/VBox/Devices/Bus/MsiCommon.h

    r32820 r32860  
    2424
    2525/* PCI config space accessors for MSI registers */
    26 void     MSIPciConfigWrite(PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len);
    27 uint32_t MSIPciConfigRead (PPCIDEVICE pDev, uint32_t u32Address, unsigned len);
     26void     MSIPciConfigWrite(PPDMDEVINS pDevIns, PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len);
     27uint32_t MSIPciConfigRead (PPDMDEVINS pDevIns, PPCIDEVICE pDev, uint32_t u32Address, unsigned len);
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