VirtualBox

Changeset 44902 in vbox for trunk


Ignore:
Timestamp:
Mar 2, 2013 2:28:37 AM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84072
Message:

Relevant PDMDevHlpPhysWrite changed to PDMDevHlpPCIPhysWrite. If this breaks anything, add PDM_DO_NOT_RESPECT_PCI_BM_BIT to VMM_COMMON_DEFS to disable the feature.

Location:
trunk/src/VBox
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r44632 r44902  
    732732            break;
    733733        }
    734         PDMDevHlpPhysWrite(pDevIns, addr, tmpbuf, acquired);
     734        PDMDevHlpPCIPhysWrite(pDevIns, addr, tmpbuf, acquired);
    735735        temp  -= acquired;
    736736        addr  += acquired;

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

    r44761 r44902  
    769769{
    770770    if (pThis->u64DPBase & DPBASE_ENABLED)
    771         PDMDevHlpPhysWrite(pThis->pDevIns,
    772                            (pThis->u64DPBase & DPBASE_ADDR_MASK) + pStreamDesc->u8Strm * 8,
    773                            pStreamDesc->pu32Lpib, sizeof(uint32_t));
     771        PDMDevHlpPCIPhysWrite(pThis->pDevIns,
     772                              (pThis->u64DPBase & DPBASE_ADDR_MASK) + pStreamDesc->u8Strm * 8,
     773                              pStreamDesc->pu32Lpib, sizeof(uint32_t));
    774774}
    775775DECLINLINE(uint32_t) hdaFifoWToSz(PHDASTATE pThis, PHDASTREAMTRANSFERDESC pStreamDesc)
    … …  
    955955    {
    956956        Assert((HDA_REG_FLAG_VALUE(pThis, RIRBCTL, DMA)));
    957         rc = PDMDevHlpPhysWrite(pThis->pDevIns, pThis->u64RIRBBase, pThis->pu64RirbBuf, pThis->cbRirbBuf);
     957        rc = PDMDevHlpPCIPhysWrite(pThis->pDevIns, pThis->u64RIRBBase, pThis->pu64RirbBuf, pThis->cbRirbBuf);
    958958        if (RT_FAILURE(rc))
    959959            AssertRCReturn(rc, rc);
    … …  
    18481848         * write the HDA DMA buffer
    18491849         */
    1850         PDMDevHlpPhysWrite(pThis->pDevIns, pBdle->u64BdleCviAddr + pBdle->u32BdleCviPos, pBdle->au8HdaBuffer, cbBackendCopy);
     1850        PDMDevHlpPCIPhysWrite(pThis->pDevIns, pBdle->u64BdleCviAddr + pBdle->u32BdleCviPos, pBdle->au8HdaBuffer, cbBackendCopy);
    18511851
    18521852        /* Don't see any reason why cb2Copy would differ from cbBackendCopy */

  • trunk/src/VBox/Devices/Network/DevE1000.cpp

    r44852 r44902  
    21092109    // uint32_t rdh = RDH;
    21102110    // Assert(pThis->aRxDescAddr[pDesc - pThis->aRxDescriptors] == addr);
    2111     PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns),
    2112                        e1kDescAddr(RDBAH, RDBAL, RDH),
    2113                        pDesc, sizeof(E1KRXDESC));
     2111    PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns),
     2112                          e1kDescAddr(RDBAH, RDBAL, RDH),
     2113                          pDesc, sizeof(E1KRXDESC));
    21142114    e1kAdvanceRDH(pThis);
    21152115    e1kPrintRDesc(pThis, pDesc);
    … …  
    21292129    E1kLog2(("%s e1kStoreRxFragment: store fragment of %04X at %016LX, EOP=%d\n",
    21302130             pThis->szPrf, cb, pDesc->u64BufAddr, pDesc->status.fEOP));
    2131     PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), pDesc->u64BufAddr, pvBuf, cb);
     2131    PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), pDesc->u64BufAddr, pvBuf, cb);
    21322132    pDesc->u16Length = (uint16_t)cb;                        Assert(pDesc->u16Length == cb);
    21332133    STAM_PROFILE_ADV_STOP(&pThis->StatReceiveStore, a);
    … …  
    21512151    STAM_PROFILE_ADV_START(&pThis->StatReceiveStore, a);
    21522152    E1kLog2(("%s e1kStoreRxFragment: store fragment of %04X at %016LX, EOP=%d\n", pThis->szPrf, cb, pDesc->u64BufAddr, pDesc->status.fEOP));
    2153     PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), pDesc->u64BufAddr, pvBuf, cb);
     2153    PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), pDesc->u64BufAddr, pvBuf, cb);
    21542154    pDesc->u16Length = (uint16_t)cb;                        Assert(pDesc->u16Length == cb);
    21552155    /* Write back the descriptor */
    2156     PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), e1kDescAddr(RDBAH, RDBAL, RDH), pDesc, sizeof(E1KRXDESC));
     2156    PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), e1kDescAddr(RDBAH, RDBAL, RDH), pDesc, sizeof(E1KRXDESC));
    21572157    e1kPrintRDesc(pThis, pDesc);
    21582158    E1kLogRel(("E1000: Wrote back RX desc, RDH=%x\n", RDH));
    … …  
    36883688    /* Only the last half of the descriptor has to be written back. */
    36893689    e1kPrintTDesc(pThis, pDesc, "^^^");
    3690     PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), addr, pDesc, sizeof(E1KTXDESC));
     3690    PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), addr, pDesc, sizeof(E1KTXDESC));
    36913691}
    36923692

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r44895 r44902  
    742742        xda[3] =   ((uint32_t *)tmd)[2] >> 16;
    743743        xda[1] |=  0x8000;
    744         PDMDevHlpPhysWrite(pDevIns, addr, (void*)&xda[0], sizeof(xda));
     744        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)&xda[0], sizeof(xda));
    745745        xda[1] &= ~0x8000;
    746         PDMDevHlpPhysWrite(pDevIns, addr+3, (uint8_t*)xda + 3, 1);
     746        PDMDevHlpPCIPhysWrite(pDevIns, addr+3, (uint8_t*)xda + 3, 1);
    747747    }
    748748    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
    749749    {
    750750        ((uint32_t*)tmd)[1] |=  0x80000000;
    751         PDMDevHlpPhysWrite(pDevIns, addr, (void*)tmd, 16);
     751        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)tmd, 16);
    752752        ((uint32_t*)tmd)[1] &= ~0x80000000;
    753         PDMDevHlpPhysWrite(pDevIns, addr+7, (uint8_t*)tmd + 7, 1);
     753        PDMDevHlpPCIPhysWrite(pDevIns, addr+7, (uint8_t*)tmd + 7, 1);
    754754    }
    755755    else
    … …  
    761761        xda[3] = ((uint32_t *)tmd)[3];
    762762        xda[1] |=  0x80000000;
    763         PDMDevHlpPhysWrite(pDevIns, addr, (void*)&xda[0], sizeof(xda));
     763        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)&xda[0], sizeof(xda));
    764764        xda[1] &= ~0x80000000;
    765         PDMDevHlpPhysWrite(pDevIns, addr+7, (uint8_t*)xda + 7, 1);
     765        PDMDevHlpPCIPhysWrite(pDevIns, addr+7, (uint8_t*)xda + 7, 1);
    766766    }
    767767    STAM_PROFILE_ADV_STOP(&pThis->CTX_SUFF_Z(StatTmdStore), a);
    … …  
    860860        rda[3] =   ((uint32_t *)rmd)[2]      & 0xffff;
    861861        rda[1] |=  0x8000;
    862         PDMDevHlpPhysWrite(pDevIns, addr, (void*)&rda[0], sizeof(rda));
     862        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)&rda[0], sizeof(rda));
    863863        rda[1] &= ~0x8000;
    864         PDMDevHlpPhysWrite(pDevIns, addr+3, (uint8_t*)rda + 3, 1);
     864        PDMDevHlpPCIPhysWrite(pDevIns, addr+3, (uint8_t*)rda + 3, 1);
    865865    }
    866866    else if (RT_LIKELY(BCR_SWSTYLE(pThis) != 3))
    867867    {
    868868        ((uint32_t*)rmd)[1] |=  0x80000000;
    869         PDMDevHlpPhysWrite(pDevIns, addr, (void*)rmd, 16);
     869        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)rmd, 16);
    870870        ((uint32_t*)rmd)[1] &= ~0x80000000;
    871         PDMDevHlpPhysWrite(pDevIns, addr+7, (uint8_t*)rmd + 7, 1);
     871        PDMDevHlpPCIPhysWrite(pDevIns, addr+7, (uint8_t*)rmd + 7, 1);
    872872    }
    873873    else
    … …  
    879879        rda[3] = ((uint32_t *)rmd)[3];
    880880        rda[1] |=  0x80000000;
    881         PDMDevHlpPhysWrite(pDevIns, addr, (void*)&rda[0], sizeof(rda));
     881        PDMDevHlpPCIPhysWrite(pDevIns, addr, (void*)&rda[0], sizeof(rda));
    882882        rda[1] &= ~0x80000000;
    883         PDMDevHlpPhysWrite(pDevIns, addr+7, (uint8_t*)rda + 7, 1);
     883        PDMDevHlpPCIPhysWrite(pDevIns, addr+7, (uint8_t*)rda + 7, 1);
    884884    }
    885885}
    … …  
    887887#ifdef IN_RING3
    888888/**
    889  * Read+Write a TX/RX descriptor to prevent PDMDevHlpPhysWrite() allocating
     889 * Read+Write a TX/RX descriptor to prevent PDMDevHlpPCIPhysWrite() allocating
    890890 * pages later when we shouldn't schedule to EMT. Temporarily hack.
    891891 */
    … …  
    903903            cbDesc = 16;
    904904        PDMDevHlpPhysRead(pDevIns, addr, aBuf, cbDesc);
    905         PDMDevHlpPhysWrite(pDevIns, addr, aBuf, cbDesc);
     905        PDMDevHlpPCIPhysWrite(pDevIns, addr, aBuf, cbDesc);
    906906    }
    907907}
    … …  
    20012001             */
    20022002            PDMCritSectLeave(&pThis->CritSect);
    2003             PDMDevHlpPhysWrite(pDevIns, rbadr, src, cbBuf);
     2003            PDMDevHlpPCIPhysWrite(pDevIns, rbadr, src, cbBuf);
    20042004            int rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    20052005            AssertReleaseRC(rc);
    … …  
    20482048                 * handler associated with it. See above for additional comments. */
    20492049                PDMCritSectLeave(&pThis->CritSect);
    2050                 PDMDevHlpPhysWrite(pDevIns, rbadr2, src, cbBuf);
     2050                PDMDevHlpPCIPhysWrite(pDevIns, rbadr2, src, cbBuf);
    20512051                rc = PDMCritSectEnter(&pThis->CritSect, VERR_SEM_BUSY);
    20522052                AssertReleaseRC(rc);

  • trunk/src/VBox/Devices/Network/DevVirtioNet.cpp

    r44857 r44902  
    861861    {
    862862        Hdr.u16NumBufs = nElem;
    863         int rc = PDMDevHlpPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns), addrHdrMrx,
    864                                     &Hdr, sizeof(Hdr));
     863        int rc = PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns), addrHdrMrx,
     864                                       &Hdr, sizeof(Hdr));
    865865        if (RT_FAILURE(rc))
    866866        {
    … …  
    15401540            Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pThis),
    15411541                 CtlHdr.u8Class, u8Ack));
    1542             PDMDevHlpPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns),
    1543                                elem.aSegsIn[elem.nIn - 1].addr,
    1544                                &u8Ack, sizeof(u8Ack));
     1542            PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns),
     1543                                  elem.aSegsIn[elem.nIn - 1].addr,
     1544                                  &u8Ack, sizeof(u8Ack));
    15451545        }
    15461546        vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(u8Ack));

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r44574 r44902  
    27862786
    27872787        /* Post the FIS into memory. */
    2788         ahciLog(("%s: PDMDevHlpPhysWrite GCPhysAddrRecFis=%RGp cbFis=%u\n", __FUNCTION__, GCPhysAddrRecFis, cbFis));
    2789         PDMDevHlpPhysWrite(pAhciPort->CTX_SUFF(pDevIns), GCPhysAddrRecFis, pCmdFis, cbFis);
     2788        ahciLog(("%s: PDMDevHlpPCIPhysWrite GCPhysAddrRecFis=%RGp cbFis=%u\n", __FUNCTION__, GCPhysAddrRecFis, cbFis));
     2789        PDMDevHlpPCIPhysWrite(pAhciPort->CTX_SUFF(pDevIns), GCPhysAddrRecFis, pCmdFis, cbFis);
    27902790    }
    27912791
    … …  
    40564056
    40574057    /* Write updated command header into memory of the guest. */
    4058     PDMDevHlpPhysWrite(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr,
    4059                        &pAhciReq->cmdHdr, sizeof(CmdHdr));
     4058    PDMDevHlpPCIPhysWrite(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr, &pAhciReq->cmdHdr, sizeof(CmdHdr));
    40604059
    40614060    return rcSourceSink;
    … …  
    52105209    do
    52115210    {
    5212         uint32_t cPrdtlEntriesRead =   (cPrdtlEntries < RT_ELEMENTS(aPrdtlEntries))
    5213                                      ? cPrdtlEntries
    5214                                      : RT_ELEMENTS(aPrdtlEntries);
     5211        uint32_t cPrdtlEntriesRead = cPrdtlEntries < RT_ELEMENTS(aPrdtlEntries)
     5212                                   ? cPrdtlEntries
     5213                                   : RT_ELEMENTS(aPrdtlEntries);
    52155214
    52165215        PDMDevHlpPhysRead(pDevIns, GCPhysPrdtl, &aPrdtlEntries[0], cPrdtlEntriesRead * sizeof(SGLEntry));
    … …  
    52245223
    52255224            /* Copy into SG entry. */
    5226             PDMDevHlpPhysWrite(pDevIns, GCPhysAddrDataBase, pbBuf, cbThisCopy);
     5225            PDMDevHlpPCIPhysWrite(pDevIns, GCPhysAddrDataBase, pbBuf, cbThisCopy);
    52275226
    52285227            pbBuf    += cbThisCopy;
    … …  
    57095708
    57105709            /* Write updated command header into memory of the guest. */
    5711             PDMDevHlpPhysWrite(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr,
    5712                                &pAhciReq->cmdHdr, sizeof(CmdHdr));
     5710            PDMDevHlpPCIPhysWrite(pAhciPort->CTX_SUFF(pDevIns), pAhciReq->GCPhysCmdHdrAddr, &pAhciReq->cmdHdr, sizeof(CmdHdr));
    57135711
    57145712            if (pAhciReq->fFlags & AHCI_REQ_OVERFLOW)

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r44888 r44902  
    11861186    pTaskState->CommandControlBlockGuest.c.uDeviceStatus      = uDeviceStatus;
    11871187    /* Rewrite CCB up to the CDB; perhaps more than necessary. */
    1188     PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrCCB, &pTaskState->CommandControlBlockGuest, RT_OFFSETOF(CCBC, abCDB));
     1188    PDMDevHlpPCIPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrCCB,
     1189                          &pTaskState->CommandControlBlockGuest, RT_OFFSETOF(CCBC, abCDB));
    11891190
    11901191# ifdef RT_STRICT
    … …  
    12031204        U32_TO_ADDR(Mbx24.aPhysAddrCCB, pTaskState->MailboxGuest.u32PhysAddrCCB);
    12041205        Log(("24-bit mailbox: completion code=%u, CCB at %RGp\n", Mbx24.uCmdState, (RTGCPHYS)ADDR_TO_U32(Mbx24.aPhysAddrCCB)));
    1205         PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming, &Mbx24, sizeof(Mailbox24));
     1206        PDMDevHlpPCIPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming, &Mbx24, sizeof(Mailbox24));
    12061207    }
    12071208    else
    12081209    {
    12091210        Log(("32-bit mailbox: completion code=%u, CCB at %RGp\n", pTaskState->MailboxGuest.u.in.uCompletionCode, (RTGCPHYS)pTaskState->MailboxGuest.u32PhysAddrCCB));
    1210         PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming, &pTaskState->MailboxGuest, sizeof(Mailbox32));
     1211        PDMDevHlpPCIPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxIncoming,
     1212                              &pTaskState->MailboxGuest, sizeof(Mailbox32));
    12111213    }
    12121214
    … …  
    15361538                    Log(("%s: GCPhysAddrDataBase=%RGp cbDataToTransfer=%u\n", __FUNCTION__, GCPhysAddrDataBase, cbDataToTransfer));
    15371539
    1538                     PDMDevHlpPhysWrite(pDevIns, GCPhysAddrDataBase, pbData, cbDataToTransfer);
     1540                    PDMDevHlpPCIPhysWrite(pDevIns, GCPhysAddrDataBase, pbData, cbDataToTransfer);
    15391541                    pbData += cbDataToTransfer;
    15401542                }
    … …  
    15591561
    15601562            /* Copy the data into the guest memory. */
    1561             PDMDevHlpPhysWrite(pDevIns, GCPhysAddrDataBase, pTaskState->DataSeg.pvSeg, pTaskState->DataSeg.cbSeg);
     1563            PDMDevHlpPCIPhysWrite(pDevIns, GCPhysAddrDataBase, pTaskState->DataSeg.pvSeg, pTaskState->DataSeg.cbSeg);
    15621564        }
    15631565
    … …  
    16271629            GCPhysAddrSenseBuffer = pTaskState->CommandControlBlockGuest.n.u32PhysAddrSenseData;
    16281630
    1629         PDMDevHlpPhysWrite(pDevIns, GCPhysAddrSenseBuffer, pTaskState->pbSenseBuffer, cbSenseBuffer);
     1631        PDMDevHlpPCIPhysWrite(pDevIns, GCPhysAddrSenseBuffer, pTaskState->pbSenseBuffer, cbSenseBuffer);
    16301632    }
    16311633
    … …  
    29752977    uint8_t uActionCode = BUSLOGIC_MAILBOX_OUTGOING_ACTION_FREE;
    29762978    unsigned uCodeOffs = pTaskState->fIs24Bit ? RT_OFFSETOF(Mailbox24, uCmdState) : RT_OFFSETOF(Mailbox32, u.out.uActionCode);
    2977     PDMDevHlpPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxCurrent + uCodeOffs, &uActionCode, sizeof(uActionCode));
     2979    PDMDevHlpPCIPhysWrite(pBusLogic->CTX_SUFF(pDevIns), GCPhysAddrMailboxCurrent + uCodeOffs, &uActionCode, sizeof(uActionCode));
    29782980
    29792981    if (pTaskState->MailboxGuest.u.out.uActionCode == BUSLOGIC_MAILBOX_OUTGOING_ACTION_START_COMMAND)

  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r44779 r44902  
    707707
    708708        /* Write reply to guest memory. */
    709         PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysReplyMessage, pReply, cbReplyCopied);
     709        PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysReplyMessage, pReply, cbReplyCopied);
    710710
    711711        /* Write low 32bits of reply frame into post reply queue. */
    … …  
    14461446
    14471447    /* Copy into SG entry. */
    1448     PDMDevHlpPhysWrite(pDevIns, GCPhysBuffer, pSGInfo->pvBuf, pSGInfo->cbBuf);
     1448    PDMDevHlpPCIPhysWrite(pDevIns, GCPhysBuffer, pSGInfo->pvBuf, pSGInfo->cbBuf);
    14491449
    14501450}
    … …  
    21652165
    21662166            /* Copy the sense buffer over. */
    2167             PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysAddrSenseBuffer, pTaskState->abSenseBuffer,
    2168                                  RT_UNLIKELY(pTaskState->GuestRequest.SCSIIO.u8SenseBufferLength < pTaskState->PDMScsiRequest.cbSenseBuffer)
    2169                                ? pTaskState->GuestRequest.SCSIIO.u8SenseBufferLength
    2170                                : pTaskState->PDMScsiRequest.cbSenseBuffer);
     2167            PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysAddrSenseBuffer, pTaskState->abSenseBuffer,
     2168                                  RT_UNLIKELY(  pTaskState->GuestRequest.SCSIIO.u8SenseBufferLength
     2169                                              < pTaskState->PDMScsiRequest.cbSenseBuffer)
     2170                                  ? pTaskState->GuestRequest.SCSIIO.u8SenseBufferLength
     2171                                  : pTaskState->PDMScsiRequest.cbSenseBuffer);
    21712172# endif
    21722173            lsilogicR3ScatterGatherListDestroy(pThis, pTaskState);
    … …  
    29892990                    GCPhysAddrPageBuffer |= (uint64_t)pConfigurationReq->SimpleSGElement.u32DataBufferAddressHigh << 32;
    29902991
    2991                 PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysAddrPageBuffer, pbPageData,
    2992                                    RT_MIN(cbBuffer, cbPage));
     2992                PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), GCPhysAddrPageBuffer, pbPageData, RT_MIN(cbBuffer, cbPage));
    29932993            }
    29942994            break;

  • trunk/src/VBox/Devices/USB/DevOHCI.cpp

    r44835 r44902  
    11351135{
    11361136    if (cbBuf)
    1137         PDMDevHlpPhysWrite(pThis->CTX_SUFF(pDevIns), Addr, pvBuf, cbBuf);
     1137        PDMDevHlpPCIPhysWrite(pThis->CTX_SUFF(pDevIns), Addr, pvBuf, cbBuf);
    11381138}
    11391139

  • trunk/src/VBox/Devices/VirtIO/Virtio.cpp

    r44856 r44902  
    109109        tmp |= VRINGUSED_F_NO_NOTIFY;
    110110
    111     PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
    112                        pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uFlags),
    113                        &tmp, sizeof(tmp));
     111    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
     112                          pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uFlags),
     113                          &tmp, sizeof(tmp));
    114114}
    115115
    … …  
    181181void vringWriteUsedIndex(PVPCISTATE pState, PVRING pVRing, uint16_t u16Value)
    182182{
    183     PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
    184                        pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uIndex),
    185                        &u16Value, sizeof(u16Value));
     183    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
     184                          pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, uIndex),
     185                          &u16Value, sizeof(u16Value));
    186186}
    187187
    … …  
    192192    elem.uId = uId;
    193193    elem.uLen = uLen;
    194     PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns),
    195                        pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, aRing[uIndex % pVRing->uSize]),
    196                        &elem, sizeof(elem));
     194    PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns),
     195                          pVRing->addrUsed + RT_OFFSETOF(VRINGUSED, aRing[uIndex % pVRing->uSize]),
     196                          &elem, sizeof(elem));
    197197}
    198198
    … …  
    210210            Log2(("%s vqueuePut: %s used_idx=%u seg=%u addr=%p pv=%p cb=%u acb=%u\n", INSTANCE(pState),
    211211                  QUEUENAME(pState, pQueue), pQueue->uNextUsedIndex, i, pElem->aSegsIn[i].addr, pElem->aSegsIn[i].pv, pElem->aSegsIn[i].cb, cbSegLen));
    212             PDMDevHlpPhysWrite(pState->CTX_SUFF(pDevIns), pElem->aSegsIn[i].addr + cbReserved,
    213                                pElem->aSegsIn[i].pv, cbSegLen);
     212            PDMDevHlpPCIPhysWrite(pState->CTX_SUFF(pDevIns), pElem->aSegsIn[i].addr + cbReserved,
     213                                  pElem->aSegsIn[i].pv, cbSegLen);
    214214            cbReserved = 0;
    215215        }

  • trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

    r44899 r44902  
    7272    PDMDEV_ASSERT_DEVINS(pDevIns);
    7373
     74#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    7475    /*
    7576     * Just check the busmaster setting here and forward the request to the generic read helper.
    … …  
    8485        return VERR_PDM_NOT_PCI_BUS_MASTER;
    8586    }
     87#endif
    8688
    8789    return pDevIns->pHlpR0->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
    … …  
    9496    PDMDEV_ASSERT_DEVINS(pDevIns);
    9597
     98#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    9699    /*
    97100     * Just check the busmaster setting here and forward the request to the generic read helper.
    … …  
    106109        return VERR_PDM_NOT_PCI_BUS_MASTER;
    107110    }
     111#endif
    108112
    109113    return pDevIns->pHlpR0->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);

  • trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp

    r44898 r44902  
    13571357    PDMDEV_ASSERT_DEVINS(pDevIns);
    13581358
     1359#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    13591360    /*
    13601361     * Just check the busmaster setting here and forward the request to the generic read helper.
    … …  
    13691370        return VERR_PDM_NOT_PCI_BUS_MASTER;
    13701371    }
     1372#endif
    13711373
    13721374    return pDevIns->pHlpR3->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
    … …  
    13791381    PDMDEV_ASSERT_DEVINS(pDevIns);
    13801382
     1383#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    13811384    /*
    13821385     * Just check the busmaster setting here and forward the request to the generic read helper.
    … …  
    13911394        return VERR_PDM_NOT_PCI_BUS_MASTER;
    13921395    }
     1396#endif
    13931397
    13941398    return pDevIns->pHlpR3->pfnPhysWrite(pDevIns, GCPhys, pvBuf, cbWrite);

  • trunk/src/VBox/VMM/VMMRC/PDMRCDevice.cpp

    r44899 r44902  
    6969    PDMDEV_ASSERT_DEVINS(pDevIns);
    7070
     71#ifndef PDM_DO_NOT_RESPECT_PCI_BM_BIT
    7172    /*
    7273     * Just check the busmaster setting here and forward the request to the generic read helper.
    … …  
    8182        return VERR_PDM_NOT_PCI_BUS_MASTER;
    8283    }
     84#endif
    8385
    8486    return pDevIns->pHlpRC->pfnPhysRead(pDevIns, GCPhys, pvBuf, cbRead);
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