Changeset 81033 in vbox

Timestamp:

Sep 26, 2019 7:44:09 PM (5 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

133636

Message:

DevPci*: Eliminated DevPciMerge1.cpp.h.

Location:

trunk/src/VBox/Devices/Bus

Files:

• DevPCI.cpp (modified) (3 diffs)
• DevPciIch9.cpp (modified) (4 diffs)
• DevPciInternal.h (modified) (1 diff)
• DevPciMerge1.cpp.h (deleted)

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

@@ -920 +920 @@
 
 
-/*
- * Include code we share with the other PCI bus implementation.
- *
- * Note! No #ifdefs, use instant data booleans/flags/whatever.  Goal is to
- *       completely merge these files!  File #1 contains code we write, where
- *       as a possible file #2 contains external code if there's any left.
- */
-# include "DevPciMerge1.cpp.h"
-
-
 /* -=-=-=-=-=- Saved state -=-=-=-=-=- */
 
@@ -1308 +1298 @@
     PDMPCIBUSREGCC PciBusReg;
     PciBusReg.u32Version                 = PDM_PCIBUSREGCC_VERSION;
-    PciBusReg.pfnRegisterR3              = pciR3MergedRegister;
+    PciBusReg.pfnRegisterR3              = devpciR3CommonRegisterDevice;
     PciBusReg.pfnRegisterMsiR3           = NULL;
     PciBusReg.pfnIORegionRegisterR3      = devpciR3CommonIORegionRegister;
@@ -1755 +1745 @@
     PDMPCIBUSREGCC PciBusReg;
     PciBusReg.u32Version                 = PDM_PCIBUSREGCC_VERSION;
-    PciBusReg.pfnRegisterR3              = pcibridgeR3MergedRegisterDevice;
+    PciBusReg.pfnRegisterR3              = devpcibridgeR3CommonRegisterDevice;
     PciBusReg.pfnRegisterMsiR3           = NULL;
     PciBusReg.pfnIORegionRegisterR3      = devpciR3CommonIORegionRegister;

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

@@ -747 +747 @@
 #ifdef IN_RING3
 
-/*
- * Include code we share with the other PCI bus implementation.
- *
- * Note! No #ifdefs, use instant data booleans/flags/whatever.  Goal is to
- *       completely merge these files!  File #1 contains code we write, where
- *       as a possible file #2 contains external code if there's any left.
- */
-# include "DevPciMerge1.cpp.h"
-
-
 DECLINLINE(PPDMPCIDEV) ich9pciFindBridge(PDEVPCIBUS pBus, uint8_t uBus)
 {
@@ -818 +808 @@
 
 /* -=-=-=-=-=- PCI Bus Interface Methods (PDMPCIBUSREG) -=-=-=-=-=- */
+
+/**
+ * Search for a completely unused device entry (all 8 functions are unused).
+ *
+ * @returns VBox status code.
+ * @param   pBus            The bus to register with.
+ * @remarks Caller enters the PDM critical section.
+ */
+static uint8_t devpciR3CommonFindUnusedDeviceNo(PDEVPCIBUS pBus)
+{
+    for (uint8_t uPciDevNo = pBus->iDevSearch >> VBOX_PCI_DEVFN_DEV_SHIFT; uPciDevNo < VBOX_PCI_MAX_DEVICES; uPciDevNo++)
+        if (   !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 0)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 1)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 2)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 3)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 4)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 5)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 6)]
+            && !pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, 7)])
+            return uPciDevNo;
+    return UINT8_MAX;
+}
+
+
+
+/**
+ * Registers the device with the specified PCI bus.
+ *
+ * This is shared between the pci bus and pci bridge code.
+ *
+ * @returns VBox status code.
+ * @param   pDevIns         The PCI bus device instance.
+ * @param   pBus            The bus to register with.
+ * @param   pPciDev         The PCI device structure.
+ * @param   fFlags          Reserved for future use, PDMPCIDEVREG_F_MBZ.
+ * @param   uPciDevNo       PDMPCIDEVREG_DEV_NO_FIRST_UNUSED, or a specific
+ *                          device number (0-31).
+ * @param   uPciFunNo       PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, or a specific
+ *                          function number (0-7).
+ * @param   pszName         Device name (static but not unique).
+ *
+ * @remarks Caller enters the PDM critical section.
+ */
+static int devpciR3CommonRegisterDeviceOnBus(PPDMDEVINS pDevIns, PDEVPCIBUS pBus, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                             uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
+{
+    RT_NOREF(pDevIns);
+
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(pszName, VERR_INVALID_POINTER);
+    AssertPtrReturn(pPciDev, VERR_INVALID_POINTER);
+    AssertReturn(!(fFlags & ~PDMPCIDEVREG_F_VALID_MASK), VERR_INVALID_FLAGS);
+    AssertReturn(uPciDevNo < VBOX_PCI_MAX_DEVICES   || uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED, VERR_INVALID_PARAMETER);
+    AssertReturn(uPciFunNo < VBOX_PCI_MAX_FUNCTIONS || uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, VERR_INVALID_PARAMETER);
+
+    /*
+     * Assign device & function numbers.
+     */
+
+    /* Work the optional assignment flag. */
+    if (fFlags & PDMPCIDEVREG_F_NOT_MANDATORY_NO)
+    {
+        AssertLogRelMsgReturn(uPciDevNo < VBOX_PCI_MAX_DEVICES && uPciFunNo < VBOX_PCI_MAX_FUNCTIONS,
+                              ("PDMPCIDEVREG_F_NOT_MANDATORY_NO not implemented for #Dev=%#x / #Fun=%#x\n", uPciDevNo, uPciFunNo),
+                              VERR_NOT_IMPLEMENTED);
+        if (pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo)])
+        {
+            uPciDevNo = PDMPCIDEVREG_DEV_NO_FIRST_UNUSED;
+            uPciFunNo = PDMPCIDEVREG_FUN_NO_FIRST_UNUSED;
+        }
+    }
+
+    if (uPciDevNo == PDMPCIDEVREG_DEV_NO_FIRST_UNUSED)
+    {
+        /* Just find the next unused device number and we're good. */
+        uPciDevNo = devpciR3CommonFindUnusedDeviceNo(pBus);
+        AssertLogRelMsgReturn(uPciDevNo < VBOX_PCI_MAX_DEVICES, ("Couldn't find a free spot!\n"), VERR_PDM_TOO_PCI_MANY_DEVICES);
+        if (uPciFunNo == PDMPCIDEVREG_FUN_NO_FIRST_UNUSED)
+            uPciFunNo = 0;
+    }
+    else
+    {
+        /*
+         * Direct assignment of device number can be more complicated.
+         */
+        PPDMPCIDEV pClash;
+        if (uPciFunNo != PDMPCIDEVREG_FUN_NO_FIRST_UNUSED)
+        {
+            /* In the case of a specified function, we only relocate an existing
+               device if it belongs to a different device instance.  Reasoning is
+               that the device should figure out it's own function assignments.
+               Note! We could make this more flexible by relocating functions assigned
+                     via PDMPCIDEVREG_FUN_NO_FIRST_UNUSED, but it can wait till it's needed. */
+            pClash = pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo)];
+            if (!pClash)
+            { /* likely */ }
+            else if (pClash->Int.s.pDevInsR3 == pPciDev->Int.s.pDevInsR3)
+                AssertLogRelMsgFailedReturn(("PCI Configuration conflict at %u.%u: %s vs %s (same pDevIns)!\n",
+                                             uPciDevNo, uPciFunNo, pClash->pszNameR3, pszName),
+                                            VERR_PDM_TOO_PCI_MANY_DEVICES);
+            else if (!pClash->Int.s.fReassignableDevNo)
+                AssertLogRelMsgFailedReturn(("PCI Configuration conflict at %u.%u: %s vs %s (different pDevIns)!\n",
+                                             uPciDevNo, uPciFunNo, pClash->pszNameR3, pszName),
+                                            VERR_PDM_TOO_PCI_MANY_DEVICES);
+        }
+        else
+        {
+            /* First unused function slot.  Again, we only relocate the whole
+               thing if all the device instance differs, because we otherwise
+               reason that a device should manage its own functions correctly. */
+            unsigned cSameDevInses = 0;
+            for (uPciFunNo = 0, pClash = NULL; uPciFunNo < VBOX_PCI_MAX_FUNCTIONS; uPciFunNo++)
+            {
+                pClash = pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo)];
+                if (!pClash)
+                    break;
+                cSameDevInses += pClash->Int.s.pDevInsR3 == pPciDev->Int.s.pDevInsR3;
+            }
+            if (!pClash)
+                Assert(uPciFunNo < VBOX_PCI_MAX_FUNCTIONS);
+            else
+                AssertLogRelMsgReturn(cSameDevInses == 0,
+                                      ("PCI Configuration conflict at %u.* appending %s (%u of %u pDevIns matches)!\n",
+                                       uPciDevNo, pszName, cSameDevInses, VBOX_PCI_MAX_FUNCTIONS),
+                                      VERR_PDM_TOO_PCI_MANY_DEVICES);
+        }
+        if (pClash)
+        {
+            /*
+             * Try relocate the existing device.
+             */
+            /* Check that all functions can be moved. */
+            for (uint8_t uMoveFun = 0; uMoveFun < VBOX_PCI_MAX_FUNCTIONS; uMoveFun++)
+            {
+                PPDMPCIDEV pMovePciDev = pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uMoveFun)];
+                AssertLogRelMsgReturn(!pMovePciDev || pMovePciDev->Int.s.fReassignableDevNo,
+                                      ("PCI Configuration conflict at %u.%u: %s vs %s\n",
+                                       uPciDevNo, uMoveFun, pMovePciDev->pszNameR3, pszName),
+                                      VERR_PDM_TOO_PCI_MANY_DEVICES);
+            }
+
+            /* Find a free device number to move it to. */
+            uint8_t uMoveToDevNo = devpciR3CommonFindUnusedDeviceNo(pBus);
+            Assert(uMoveToDevNo != uPciFunNo);
+            AssertLogRelMsgReturn(uMoveToDevNo < VBOX_PCI_MAX_DEVICES,
+                                  ("No space to relocate device at %u so '%s' can be placed there instead!\n", uPciFunNo, pszName),
+                                  VERR_PDM_TOO_PCI_MANY_DEVICES);
+
+            /* Execute the move. */
+            for (uint8_t uMoveFun = 0; uMoveFun < VBOX_PCI_MAX_FUNCTIONS; uMoveFun++)
+            {
+                PPDMPCIDEV pMovePciDev = pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uMoveFun)];
+                if (pMovePciDev)
+                {
+                    Log(("PCI: Relocating '%s' from %u.%u to %u.%u.\n", pMovePciDev->pszNameR3, uPciDevNo, uMoveFun, uMoveToDevNo, uMoveFun));
+                    pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uMoveFun)] = NULL;
+                    pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uMoveToDevNo, uMoveFun)] = pMovePciDev;
+                    pMovePciDev->uDevFn = VBOX_PCI_DEVFN_MAKE(uMoveToDevNo, uMoveFun);
+                }
+            }
+        }
+    }
+
+    /*
+     * Now, initialize the rest of the PCI device structure.
+     */
+    Assert(!pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo)]);
+    pBus->apDevices[VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo)] = pPciDev;
+
+    pPciDev->uDevFn                 = VBOX_PCI_DEVFN_MAKE(uPciDevNo, uPciFunNo);
+    pPciDev->Int.s.pBusR3           = pBus;
+    Assert(pBus == PDMINS_2_DATA(pDevIns, PDEVPCIBUS));
+    pPciDev->Int.s.pfnConfigRead    = NULL;
+    pPciDev->Int.s.pfnConfigWrite   = NULL;
+    if (pBus->fTypePiix3 && pPciDev->cbConfig > 256)
+        pPciDev->cbConfig = 256;
+
+    /* Remember and mark bridges. */
+    if (fFlags & PDMPCIDEVREG_F_PCI_BRIDGE)
+    {
+        AssertLogRelMsgReturn(pBus->cBridges < RT_ELEMENTS(pBus->apDevices),
+                              ("Number of bridges exceeds the number of possible devices on the bus\n"),
+                              VERR_INTERNAL_ERROR_3);
+        pBus->papBridgesR3[pBus->cBridges++] = pPciDev;
+        pciDevSetPci2PciBridge(pPciDev);
+    }
+
+    Log(("PCI: Registered device %d function %d (%#x) '%s'.\n",
+         uPciDevNo, uPciFunNo, UINT32_C(0x80000000) | (pPciDev->uDevFn << 8), pszName));
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @interface_method_impl{PDMPCIBUSREG,pfnRegisterR3}
+ */
+DECLCALLBACK(int) devpciR3CommonRegisterDevice(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                               uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
+{
+    PDEVPCIBUS pBus = PDMINS_2_DATA(pDevIns, PDEVPCIBUS);
+    AssertCompileMemberOffset(DEVPCIROOT, PciBus, 0);
+    return devpciR3CommonRegisterDeviceOnBus(pDevIns, pBus, pPciDev, fFlags, uPciDevNo, uPciFunNo, pszName);
+}
+
+
+/**
+ * @interface_method_impl{PDMPCIBUSREG,pfnRegisterR3}
+ */
+DECLCALLBACK(int) devpcibridgeR3CommonRegisterDevice(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                                     uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName)
+{
+    PDEVPCIBUS pBus = PDMINS_2_DATA(pDevIns, PDEVPCIBUS);
+    return devpciR3CommonRegisterDeviceOnBus(pDevIns, pBus, pPciDev, fFlags, uPciDevNo, uPciFunNo, pszName);
+}
 
 
@@ -3102 +3309 @@
     PDMPCIBUSREGCC PciBusReg;
     PciBusReg.u32Version                 = PDM_PCIBUSREGCC_VERSION;
-    PciBusReg.pfnRegisterR3              = pciR3MergedRegister;
+    PciBusReg.pfnRegisterR3              = devpciR3CommonRegisterDevice;
     PciBusReg.pfnRegisterMsiR3           = ich9pciRegisterMsi;
     PciBusReg.pfnIORegionRegisterR3      = devpciR3CommonIORegionRegister;
@@ -3430 +3637 @@
     PDMPCIBUSREGCC PciBusReg;
     PciBusReg.u32Version                 = PDM_PCIBUSREGCC_VERSION;
-    PciBusReg.pfnRegisterR3              = pcibridgeR3MergedRegisterDevice;
+    PciBusReg.pfnRegisterR3              = devpcibridgeR3CommonRegisterDevice;
     PciBusReg.pfnRegisterMsiR3           = ich9pciRegisterMsi;
     PciBusReg.pfnIORegionRegisterR3      = devpciR3CommonIORegionRegister;

trunk/src/VBox/Devices/Bus/DevPciInternal.h

@@ -203 +203 @@
 DECLCALLBACK(void) devpciR3InfoPci(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs);
 DECLCALLBACK(void) devpciR3InfoPciIrq(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs);
+DECLCALLBACK(int)  devpciR3CommonRegisterDevice(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                                uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName);
+DECLCALLBACK(int)  devpcibridgeR3CommonRegisterDevice(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, uint32_t fFlags,
+                                                      uint8_t uPciDevNo, uint8_t uPciFunNo, const char *pszName);
 DECLCALLBACK(int)  devpciR3CommonIORegionRegister(PPDMDEVINS pDevIns, PPDMPCIDEV pPciDev, int iRegion, RTGCPHYS cbRegion,
                                                   PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback);