fix: WA for VF bar resource allocation post Warm reset

On Warm reset, With default bar size set by bios, VF bar
allocation is getting failed because of bug in pci driver
which impacts SRIOV functionality.

Resize VF bar size for succesful allocation of VF bar
post warm reset.

Source: 3c072a6

Related-To: LOCI-4481

Signed-off-by: Bellekallu Rajkiran <[email protected]>

Author: bellekal

level_zero/sysman/test/unit_tests/sources/global_operations/linux/test_zes_global_operations.cpp

@@ -729,7 +729,6 @@ TEST_F(SysmanGlobalOperationsFixture, GivenGemCreateIoctlFailsWithEINVALWhenCall
 }
 
 TEST_F(SysmanGlobalOperationsFixture, GivenForceTrueWhenCallingResetThenSuccessIsReturned) {
-
     ze_result_t result = zesDeviceReset(device, true);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
 }

level_zero/tools/source/sysman/linux/os_sysman_imp.cpp

@@ -18,6 +18,7 @@
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/tools/source/sysman/firmware_util/firmware_util.h"
 #include "level_zero/tools/source/sysman/linux/fs_access.h"
+#include "level_zero/tools/source/sysman/pci/linux/os_pci_imp.h"
 
 namespace L0 {
 
@@ -377,6 +378,56 @@ void LinuxSysmanImp::clearHPIE(int fd) {
     NEO::sleep(std::chrono::seconds(10)); // Sleep for 10seconds just to make sure the change is propagated.
 }
 
+// Function to adjust VF BAR size i.e Modify VF BAR Control register.
+// size param is an encoded value described as follows:
+// 0  - 1 MB (2^20 bytes)
+// 1  - 2 MB (2^21 bytes)
+// 2  - 4 MB (2^22 bytes)
+// 3  - 8 MB (2^23 bytes)
+// .
+// .
+// .
+// b  - 2 GB (2^31 bytes)
+// 43 - 8 EB (2^63 bytes)
+ze_result_t LinuxSysmanImp::resizeVfBar(uint8_t size) {
+    std::string pciConfigNode;
+    pciConfigNode = gtDevicePath + "/config";
+
+    int fdConfig = -1;
+    fdConfig = this->openFunction(pciConfigNode.c_str(), O_RDWR);
+    if (fdConfig < 0) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                              "Config node open failed\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    std::unique_ptr<uint8_t[]> configMemory = std::make_unique<uint8_t[]>(PCI_CFG_SPACE_EXP_SIZE);
+    memset(configMemory.get(), 0, PCI_CFG_SPACE_EXP_SIZE);
+    if (this->preadFunction(fdConfig, configMemory.get(), PCI_CFG_SPACE_EXP_SIZE, 0) < 0) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                              "Read to get config space failed\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    auto reBarCapPos = L0::LinuxPciImp::getRebarCapabilityPos(configMemory.get(), true);
+    if (!reBarCapPos) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                              "VF BAR capability not found\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    auto barSizePos = reBarCapPos + PCI_REBAR_CTRL + 1; // position of VF(0) BAR SIZE.
+    if (this->pwriteFunction(fdConfig, &size, 0x01, barSizePos) < 0) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                              "Write to change VF bar size failed\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    if (this->closeFunction(fdConfig) < 0) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                              "Config node close failed\n");
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
 // A 'warm reset' is a conventional reset that is triggered across a PCI express link.
 // A warm reset is triggered either when a link is forced into electrical idle or
 // by sending TS1 and TS2 ordered sets with the hot reset bit set.
@@ -432,6 +483,31 @@ ze_result_t LinuxSysmanImp::osWarmReset() {
         return ZE_RESULT_ERROR_UNKNOWN;
     }
 
+    // PCIe port driver uses the BIOS allocated VF bars on bootup. A known bug exists in pcie port driver
+    // and is causing VF bar allocation failure in PCIe port driver after an SBR - https://bugzilla.kernel.org/show_bug.cgi?id=216795
+
+    // WA to adjust VF bar size to 2GB. The default VF bar size is 8GB and for 63VFs, 504GB need to be allocated which is failing on SBR.
+    // When configured VF bar size to 2GB, an allocation of 126GB is successful. This WA resizes VF0 bar to 2GB. Once pcie port driver
+    // issue is resolved, this WA may not be necessary. Description for 0xb is explained at function definition - resizeVfVar.
+    if (NEO::DebugManager.flags.VfBarResourceAllocationWa.get()) {
+        if (ZE_RESULT_SUCCESS != (result = resizeVfBar(0xb))) {
+            return result;
+        }
+
+        result = pFsAccess->write(cardBusPath + '/' + "remove", "1");
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                                  "Card Bus remove after resizing VF bar failed\n");
+            return result;
+        }
+
+        result = pFsAccess->write(rootPortPath + '/' + "rescan", "1");
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stdout,
+                                  "Rescanning root port failed after resizing VF bar failed\n");
+            return result;
+        }
+    }
     return result;
 }
 

level_zero/tools/source/sysman/linux/os_sysman_imp.h

@@ -105,6 +105,7 @@ class LinuxSysmanImp : public OsSysman, NEO::NonCopyableOrMovableClass {
     SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;
     static const std::string deviceDir;
     void clearHPIE(int fd);
+    ze_result_t resizeVfBar(uint8_t size);
     std::mutex fwLock;
 };
 

level_zero/tools/source/sysman/pci/linux/os_pci_imp.cpp

@@ -115,7 +115,7 @@ ze_result_t LinuxPciImp::initializeBarProperties(std::vector<zes_pci_bar_propert
     return result;
 }
 
-uint32_t LinuxPciImp::getRebarCapabilityPos() {
+uint32_t LinuxPciImp::getRebarCapabilityPos(uint8_t *configMemory, bool isVfBar) {
     uint32_t pos = PCI_CFG_SPACE_SIZE;
     uint32_t header = 0;
 
@@ -127,20 +127,23 @@ uint32_t LinuxPciImp::getRebarCapabilityPos() {
     // could be present in PCI extended configuration space are
     // represented by loopCount.
     auto loopCount = (PCI_CFG_SPACE_EXP_SIZE - PCI_CFG_SPACE_SIZE) / 8;
-    header = getDwordFromConfig(pos);
+    header = getDwordFromConfig(pos, configMemory);
     if (!header) {
         return 0;
     }
 
+    const uint32_t vfRebarCapId = 0x24;
+    uint32_t capId = isVfBar ? vfRebarCapId : PCI_EXT_CAP_ID_REBAR;
+
     while (loopCount-- > 0) {
-        if (PCI_EXT_CAP_ID(header) == PCI_EXT_CAP_ID_REBAR) {
+        if (PCI_EXT_CAP_ID(header) == capId) {
             return pos;
         }
         pos = PCI_EXT_CAP_NEXT(header);
         if (pos < PCI_CFG_SPACE_SIZE) {
             return 0;
         }
-        header = getDwordFromConfig(pos);
+        header = getDwordFromConfig(pos, configMemory);
     }
     return 0;
 }
@@ -187,14 +190,14 @@ uint16_t LinuxPciImp::getLinkCapabilityPos() {
 
 // Parse PCIe configuration space to see if resizable Bar is supported
 bool LinuxPciImp::resizableBarSupported() {
-    return (getRebarCapabilityPos() > 0);
+    return (L0::LinuxPciImp::getRebarCapabilityPos(configMemory.get(), false) > 0);
 }
 
 bool LinuxPciImp::resizableBarEnabled(uint32_t barIndex) {
     bool isBarResizable = false;
     uint32_t capabilityRegister = 0, controlRegister = 0;
     uint32_t nBars = 1;
-    auto rebarCapabilityPos = getRebarCapabilityPos();
+    auto rebarCapabilityPos = L0::LinuxPciImp::getRebarCapabilityPos(configMemory.get(), false);
 
     // If resizable Bar is not supported then return false.
     if (!rebarCapabilityPos) {
@@ -219,11 +222,11 @@ bool LinuxPciImp::resizableBarEnabled(uint32_t barIndex) {
     // -------------------------------------------------------------|
 
     // Only first Control register(at offset 008h, as shown above), could tell about number of resizable Bars
-    controlRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CTRL);
+    controlRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CTRL, configMemory.get());
     nBars = BITS(controlRegister, 5, 3); // control register's bits 5,6 and 7 contain number of resizable bars information
     for (auto barNumber = 0u; barNumber < nBars; barNumber++) {
         uint32_t barId = 0;
-        controlRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CTRL);
+        controlRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CTRL, configMemory.get());
         barId = BITS(controlRegister, 0, 3); // Control register's bit 0,1,2 tells the index of bar
         if (barId == barIndex) {
             isBarResizable = true;
@@ -236,7 +239,7 @@ bool LinuxPciImp::resizableBarEnabled(uint32_t barIndex) {
         return false;
     }
 
-    capabilityRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CAP);
+    capabilityRegister = getDwordFromConfig(rebarCapabilityPos + PCI_REBAR_CAP, configMemory.get());
     // Capability register's bit 4 to 31 indicates supported Bar sizes.
     // In possibleBarSizes, position of each set bit indicates supported bar size. Example,  if set bit
     // position of possibleBarSizes is from 0 to n, then this indicates BAR size from 2^0 MB to 2^n MB

level_zero/tools/source/sysman/pci/linux/os_pci_imp.h

@@ -26,6 +26,7 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
     bool resizableBarSupported() override;
     bool resizableBarEnabled(uint32_t barIndex) override;
     ze_result_t initializeBarProperties(std::vector<zes_pci_bar_properties_t *> &pBarProperties) override;
+    static uint32_t getRebarCapabilityPos(uint8_t *configMemory, bool isVfBar);
     LinuxPciImp() = default;
     LinuxPciImp(OsSysman *pOsSysman);
     ~LinuxPciImp() override = default;
@@ -47,7 +48,7 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
     static const std::string maxLinkSpeedFile;
     static const std::string maxLinkWidthFile;
     bool isLmemSupported = false;
-    uint32_t getDwordFromConfig(uint32_t pos) {
+    static inline uint32_t getDwordFromConfig(uint32_t pos, uint8_t *configMemory) {
         return configMemory[pos] | (configMemory[pos + 1] << 8) |
                (configMemory[pos + 2] << 16) | (configMemory[pos + 3] << 24);
     }
@@ -57,7 +58,6 @@ class LinuxPciImp : public OsPci, NEO::NonCopyableOrMovableClass {
     uint8_t getByteFromConfig(uint32_t pos, uint8_t *configMem) {
         return configMem[pos];
     }
-    uint32_t getRebarCapabilityPos();
     uint16_t getLinkCapabilityPos();
 };
 

level_zero/tools/test/unit_tests/sources/sysman/diagnostics/linux/mock_zes_sysman_diagnostics.h

@@ -19,6 +19,7 @@ const std::vector<std::string> mockSupportedDiagTypes = {"MOCKSUITE1", "MOCKSUIT
 const std::string deviceDirDiag("device");
 const std::string mockRealPathConfig("/sys/devices/pci0000:89/0000:89:02.0/config");
 const std::string mockdeviceDirDiag("/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0");
+const std::string mockdeviceDirConfig("/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0/0000:8b:01.0/0000:8c:00.0/config");
 const std::string mockDeviceName("/MOCK_DEVICE_NAME");
 const std::string mockRemove("remove");
 const std::string mockRescan("rescan");