Store hardware IP version in hardware info

Query HW IP version using ioctl helper prelim

Related-To: NEO-7457
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

level_zero/tools/test/unit_tests/sources/debug/linux/debug_session_fixtures_linux.cpp

@@ -42,7 +42,7 @@ void DebugApiLinuxMultiDeviceFixture::setUp() {
     L0::Device *device = driverHandle->devices[0];
     deviceImp = static_cast<DeviceImp *>(device);
 
-    mockDrm = new DrmQueryMock(*neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0], neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->getHardwareInfo());
+    mockDrm = new DrmQueryMock(*neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]);
     mockDrm->allowDebugAttach = true;
 
     // set config from HwInfo to have correct topology requested by tests

shared/source/helpers/hw_info.h

@@ -137,17 +137,23 @@ inline bool operator==(const RuntimeCapabilityTable &lhs, const RuntimeCapabilit
     return result;
 }
 
+struct HardwareIpVersion {
+    uint8_t architecture;
+    uint8_t release;
+    uint8_t revision;
+};
+
 struct HardwareInfo {
     HardwareInfo() = default;
     HardwareInfo(const PLATFORM *platform, const FeatureTable *featureTable, const WorkaroundTable *workaroundTable,
                  const GT_SYSTEM_INFO *gtSystemInfo, const RuntimeCapabilityTable &capabilityTable);
 
-    PLATFORM platform = {};
+    PLATFORM platform{};
-    FeatureTable featureTable = {};
+    FeatureTable featureTable{};
-    WorkaroundTable workaroundTable = {};
+    WorkaroundTable workaroundTable{};
-    alignas(4) GT_SYSTEM_INFO gtSystemInfo = {};
+    alignas(4) GT_SYSTEM_INFO gtSystemInfo{};
-
+    alignas(8) RuntimeCapabilityTable capabilityTable{};
-    alignas(8) RuntimeCapabilityTable capabilityTable = {};
+    HardwareIpVersion ipVersion{};
 };
 
 template <PRODUCT_FAMILY product>

shared/source/os_interface/linux/CMakeLists.txt

@@ -57,7 +57,6 @@ set(NEO_CORE_OS_INTERFACE_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_prelim.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_getter.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_prelim_init.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/engine_info.h
     ${CMAKE_CURRENT_SOURCE_DIR}/engine_info.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/memory_info.h

shared/source/os_interface/linux/i915_prelim.h

@@ -76,6 +76,7 @@ using NEO::PrelimI915::prelim_drm_i915_gem_vm_prefetch;
 using NEO::PrelimI915::prelim_drm_i915_gem_vm_region_ext;
 using NEO::PrelimI915::prelim_drm_i915_gem_wait_user_fence;
 using NEO::PrelimI915::prelim_drm_i915_query_distance_info;
+using NEO::PrelimI915::prelim_drm_i915_query_hw_ip_version;
 using NEO::PrelimI915::prelim_drm_i915_uuid_control;
 using NEO::PrelimI915::prelim_drm_i915_vm_bind_ext_set_pat;
 using NEO::PrelimI915::prelim_drm_i915_vm_bind_ext_user_fence;

shared/source/os_interface/linux/ioctl_helper.h

@@ -24,6 +24,7 @@ class OsContextLinux;
 class IoctlHelper;
 enum class CacheRegion : uint16_t;
 struct HardwareInfo;
+struct HardwareIpVersion;
 
 struct MemoryRegion {
     MemoryClassInstance region;
@@ -261,6 +262,8 @@ class IoctlHelperPrelim20 : public IoctlHelper {
     bool getFabricLatency(uint32_t fabricId, uint32_t &latency, uint32_t &bandwidth) override;
 
   protected:
+    bool queryHwIpVersion(EngineClassInstance &engineInfo, HardwareIpVersion &ipVersion, int &ret);
+
     bool handleExecBufferInNonBlockMode = false;
 };
 

shared/source/os_interface/linux/ioctl_helper_prelim.cpp

@@ -705,6 +705,57 @@ bool IoctlHelperPrelim20::getFabricLatency(uint32_t fabricId, uint32_t &latency,
     bandwidth = info.bandwidth;
     return true;
 }
+bool IoctlHelperPrelim20::queryHwIpVersion(EngineClassInstance &engineInfo, HardwareIpVersion &ipVersion, int &ret) {
+    QueryItem queryItem{};
+    queryItem.queryId = PRELIM_DRM_I915_QUERY_HW_IP_VERSION;
+
+    Query query{};
+    query.itemsPtr = reinterpret_cast<uint64_t>(&queryItem);
+    query.numItems = 1u;
+    ret = ioctl(DrmIoctl::Query, &query);
+
+    if (ret != 0) {
+        return false;
+    }
+
+    if (queryItem.length != sizeof(prelim_drm_i915_query_hw_ip_version)) {
+        PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr, "%s\n",
+                           "Size got from PRELIM_DRM_I915_QUERY_HW_IP_VERSION query does not match PrelimI915::prelim_drm_i915_query_hw_ip_version size");
+        return false;
+    }
+
+    prelim_drm_i915_query_hw_ip_version queryHwIpVersion{};
+    queryHwIpVersion.engine.engine_class = engineInfo.engineClass;
+    queryHwIpVersion.engine.engine_instance = engineInfo.engineInstance;
+    queryItem.dataPtr = reinterpret_cast<uint64_t>(&queryHwIpVersion);
+
+    ret = ioctl(DrmIoctl::Query, &query);
+    if (ret != 0) {
+        return false;
+    }
+
+    ipVersion.architecture = queryHwIpVersion.arch;
+    ipVersion.release = queryHwIpVersion.release;
+    ipVersion.revision = queryHwIpVersion.stepping;
+
+    return true;
+}
+
+bool IoctlHelperPrelim20::initialize() {
+    auto hwInfo = drm.getRootDeviceEnvironment().getMutableHardwareInfo();
+    EngineClassInstance engineInfo = {static_cast<uint16_t>(getDrmParamValue(DrmParam::EngineClassRender)), 0};
+    int ret = 0;
+    bool result = queryHwIpVersion(engineInfo, hwInfo->ipVersion, ret);
+    if (result == false &&
+        ret != 0 &&
+        HwInfoConfig::get(hwInfo->platform.eProductFamily)->isPlatformQuerySupported()) {
+        int err = drm.getErrno();
+        PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stderr,
+                           "ioctl(PRELIM_DRM_I915_QUERY_HW_IP_VERSION) failed with %d. errno=%d(%s)\n", ret, err, strerror(err));
+    }
+
+    return result;
+}
 
 static_assert(sizeof(MemoryClassInstance) == sizeof(prelim_drm_i915_gem_memory_class_instance));
 static_assert(offsetof(MemoryClassInstance, memoryClass) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_class));

shared/source/os_interface/linux/ioctl_helper_prelim_init.cpp

@@ -1,16 +0,0 @@
-/*
- * Copyright (C) 2022 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "shared/source/os_interface/linux/ioctl_helper.h"
-
-namespace NEO {
-
-bool IoctlHelperPrelim20::initialize() {
-    return true;
-}
-
-} // namespace NEO

shared/source/os_interface/windows/wddm/wddm.cpp

@@ -108,6 +108,7 @@ bool Wddm::init() {
     setPlatformSupportEvictIfNecessaryFlag(*hwConfig);
 
     auto preemptionMode = PreemptionHelper::getDefaultPreemptionMode(*hardwareInfo);
+    populateIpVersion(*hardwareInfo);
     rootDeviceEnvironment.setHwInfo(hardwareInfo.get());
     rootDeviceEnvironment.initGmm();
     this->rootDeviceEnvironment.getGmmClientContext()->setHandleAllocator(this->hwDeviceId->getUmKmDataTranslator()->createGmmHandleAllocator());

shared/source/os_interface/windows/wddm/wddm.h

@@ -237,6 +237,7 @@ class Wddm : public DriverModel {
     }
     void setPlatformSupportEvictIfNecessaryFlag(const HwInfoConfig &hwInfoConfig);
     void populateAdditionalAdapterInfoOptions(const ADAPTER_INFO_KMD &adapterInfo);
+    void populateIpVersion(HardwareInfo &hwInfo);
 
     GMM_GFX_PARTITIONING gfxPartition{};
     ADAPTER_BDF adapterBDF{};

shared/source/os_interface/windows/wddm/wddm_additional_adapter_info_options.cpp

@@ -11,5 +11,6 @@ namespace NEO {
 
 void Wddm::populateAdditionalAdapterInfoOptions(const ADAPTER_INFO_KMD &adapterInfo) {
 }
-
+void Wddm::populateIpVersion(HardwareInfo &hwInfo) {
+}
 } // namespace NEO

shared/test/common/libult/linux/definitions/ioctl_helper_init_calls.inl

@@ -1,12 +0,0 @@
-/*
- * Copyright (C) 2022 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-uint32_t DrmMock::ioctlCallsForHelperInitialization = 0;
-
-int DrmMock::handleRemainingRequests(DrmIoctl request, void *arg) {
-    return -1;
-}

shared/test/common/libult/linux/drm_mock.cpp

@@ -12,7 +12,6 @@
 #include "shared/source/os_interface/linux/i915.h"
 
 #include "gtest/gtest.h"
-#include "ioctl_helper_init_calls.inl"
 
 #include <cstring>
 
@@ -36,6 +35,11 @@ DrmMock::DrmMock(int fd, RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std
         I915_SCHEDULER_CAP_PREEMPTION;
 }
 
+int DrmMock::handleRemainingRequests(DrmIoctl request, void *arg) {
+    ioctlCallsCount--;
+    return -1;
+};
+
 int DrmMock::ioctl(DrmIoctl request, void *arg) {
     ioctlCallsCount++;
     ioctlCount.total++;

shared/test/common/libult/linux/drm_mock.h

@@ -153,7 +153,7 @@ class DrmMock : public Drm {
     }
 
     uint32_t getBaseIoctlCalls() {
-        return ioctlCallsForHelperInitialization + static_cast<uint32_t>(virtualMemoryIds.size());
+        return static_cast<uint32_t>(virtualMemoryIds.size());
     }
 
     static const int mockFd = 33;
@@ -193,6 +193,8 @@ class DrmMock : public Drm {
     bool callBaseIsSetPairAvailable = false;
     bool callBaseGetSetPairAvailable = false;
     bool unrecoverableContextSet = false;
+    bool failRetHwIpVersion = false;
+    bool returnInvalidHwIpVersionLength = false;
 
     bool capturedCooperativeContextRequest = false;
     bool incrementVmId = false;
@@ -292,7 +294,6 @@ class DrmMock : public Drm {
         }
         return storedGetDeviceMemoryPhysicalSizeInBytesStatus;
     }
-    static uint32_t ioctlCallsForHelperInitialization;
 };
 
 class DrmMockNonFailing : public DrmMock {

shared/test/common/libult/linux/drm_query_mock.cpp

@@ -12,8 +12,7 @@
 
 #include "gtest/gtest.h"
 
-DrmQueryMock::DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
+DrmQueryMock::DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmMock(rootDeviceEnvironment) {
-    rootDeviceEnvironment.setHwInfo(inputHwInfo);
     context.hwInfo = rootDeviceEnvironment.getHardwareInfo();
     callBaseIsVmBindAvailable = true;
 

shared/test/common/libult/linux/drm_query_mock.h

@@ -17,8 +17,7 @@ class DrmQueryMock : public DrmMock {
   public:
     using Drm::rootDeviceEnvironment;
 
-    DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmQueryMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
+    DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment);
-    DrmQueryMock(RootDeviceEnvironment &rootDeviceEnvironment, const HardwareInfo *inputHwInfo);
 
     DrmMockPrelimContext context{
         nullptr,

shared/test/common/mocks/mock_wddm.h

@@ -47,6 +47,7 @@ class WddmMock : public Wddm {
     using Wddm::pagingQueue;
     using Wddm::platformSupportsEvictIfNecessary;
     using Wddm::populateAdditionalAdapterInfoOptions;
+    using Wddm::populateIpVersion;
     using Wddm::residencyLogger;
     using Wddm::rootDeviceEnvironment;
     using Wddm::setPlatformSupportEvictIfNecessaryFlag;

shared/test/unit_test/os_interface/linux/CMakeLists.txt

@@ -56,7 +56,6 @@ if(NEO_ENABLE_i915_PRELIM_DETECTION)
        ${CMAKE_CURRENT_SOURCE_DIR}/drm_with_prelim_tests.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/ioctl_helper_tests_prelim.cpp
        ${CMAKE_CURRENT_SOURCE_DIR}/prelim_helper_func.cpp
-       ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}ioctl_helper_prelim_init_tests.cpp
   )
   if(TESTS_DG1 AND "${BRANCH_TYPE}" STREQUAL "")
     list(APPEND NEO_CORE_OS_INTERFACE_TESTS_LINUX

shared/test/unit_test/os_interface/linux/drm_engine_info_prelim_tests.cpp

@@ -214,7 +214,9 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingS
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
 
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
 
     drm->queryEngineInfo();
@@ -242,7 +244,8 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWithoutMainC
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
 
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
     drm->supportedCopyEnginesMask.set(0, false);
 
@@ -290,7 +293,8 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, giveNotAllLinkBcsEnginesWhenBi
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
 
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
     drm->supportedCopyEnginesMask.set(2, false);
     drm->supportedCopyEnginesMask.set(7, false);
@@ -338,7 +342,8 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DrmTestXeHPAndLater, givenLinkBcsEngineWhenBindingM
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0b1111;
 
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
 
     drm->queryEngineInfo();
@@ -368,7 +373,8 @@ HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContext
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 0;
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
     drm->queryEngineInfo();
     EXPECT_NE(nullptr, drm->engineInfo);
@@ -396,7 +402,8 @@ HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesEnabledWhenCreatingContext
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 0;
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
     drm->queryEngineInfo();
     EXPECT_NE(nullptr, drm->engineInfo);
@@ -424,7 +431,8 @@ HWTEST2_F(DrmTestXeHPCAndLater, givenBcsVirtualEnginesDisabledWhenCreatingContex
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 0;
     localHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0;
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], &localHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&localHwInfo);
+    auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     ASSERT_NE(nullptr, drm);
     drm->supportedCopyEnginesMask = maxNBitValue(9);
     drm->queryEngineInfo();
@@ -799,7 +807,7 @@ struct DistanceQueryDrmTests : ::testing::Test {
     }
 
     std::unique_ptr<MyDrm> createDrm(bool supportDistanceInfoQuery) {
-        auto drm = std::make_unique<MyDrm>(*rootDeviceEnvironment, rootDeviceEnvironment->getHardwareInfo());
+        auto drm = std::make_unique<MyDrm>(*rootDeviceEnvironment);
         drm->supportDistanceInfoQuery = supportDistanceInfoQuery;
         return drm;
     }

shared/test/unit_test/os_interface/linux/drm_engine_info_tests.cpp

@@ -18,9 +18,9 @@ TEST(DrmTest, whenQueryingEngineInfoThenSingleIoctlIsCalled) {
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
     std::unique_ptr<DrmMock> drm = std::make_unique<DrmMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     EXPECT_NE(nullptr, drm);
-
+    auto ioctlCount = drm->ioctlCount.total.load();
     drm->queryEngineInfo();
-    EXPECT_EQ(1u + drm->getBaseIoctlCalls(), drm->ioctlCallsCount);
+    EXPECT_EQ(1 + ioctlCount, drm->ioctlCount.total.load());
 }
 
 TEST(EngineInfoTest, givenEngineInfoQuerySupportedWhenQueryingEngineInfoThenEngineInfoIsCreatedWithEngines) {

shared/test/unit_test/os_interface/linux/drm_memory_info_prelim_tests.cpp

@@ -93,7 +93,7 @@ struct DrmVmTestFixture {
         testHwInfo->gtSystemInfo.MultiTileArchInfo.TileMask = 0b1111;
         executionEnvironment->rootDeviceEnvironments[0]->initGmm();
 
-        drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0], testHwInfo);
+        drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
         ASSERT_NE(nullptr, drm);
     }
 
@@ -193,7 +193,7 @@ struct MultiTileMemoryInfoFixture : public ::testing::Test {
         multiTileArch.TileCount = tileCount;
         multiTileArch.TileMask = static_cast<uint8_t>(maxNBitValue(tileCount));
 
-        drm = std::make_unique<DrmQueryMock>(*rootDeviceEnvironment, rootDeviceEnvironment->getHardwareInfo());
+        drm = std::make_unique<DrmQueryMock>(*rootDeviceEnvironment);
 
         memoryInfo = new MemoryInfo(regionInfo, *drm);
         drm->memoryInfo.reset(memoryInfo);
@@ -417,7 +417,7 @@ TEST(MemoryInfo, givenMemoryInfoWithRegionsWhenCreatingGemExtWithPairHandleThenR
     regionInfo[1].region = {drm_i915_gem_memory_class::I915_MEMORY_CLASS_DEVICE, 0};
     regionInfo[1].probedSize = 16 * GB;
 
-    auto executionEnvironment = std::make_unique<ExecutionEnvironment>();
+    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
     executionEnvironment->prepareRootDeviceEnvironments(1);
     auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment->rootDeviceEnvironments[0]);
     drm->context.setPairQueryValue = 1;

shared/test/unit_test/os_interface/linux/drm_memory_manager_localmem_prelim_tests.cpp

@@ -2025,7 +2025,7 @@ TEST_F(DrmMemoryManagerTestPrelim, givenDrmMemoryManagerWhenGetLocalMemorySizeIs
 
     MockExecutionEnvironment executionEnvironment(&hwInfo, true, 4u);
     for (auto i = 0u; i < 4u; i++) {
-        auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment.rootDeviceEnvironments[i], &hwInfo);
+        auto drm = std::make_unique<DrmQueryMock>(*executionEnvironment.rootDeviceEnvironments[i]);
         ASSERT_NE(nullptr, drm);
 
         executionEnvironment.rootDeviceEnvironments[i]->osInterface = std::make_unique<OSInterface>();

shared/test/unit_test/os_interface/linux/drm_query_prelim_tests.cpp

@@ -313,7 +313,8 @@ TEST(DrmBufferObjectTestPrelim, givenLocalMemoryEnabledWhenCreateDrmVirtualMemor
     testHwInfo.gtSystemInfo.MultiTileArchInfo.TileCount = 1;
     testHwInfo.gtSystemInfo.MultiTileArchInfo.Tile0 = 1;
     testHwInfo.gtSystemInfo.MultiTileArchInfo.TileMask = 0b1;
-    DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0], &testHwInfo);
+    executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&testHwInfo);
+    DrmQueryMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
 
     uint32_t vmId = 0;
     drm.createDrmVirtualMemory(vmId);

shared/test/unit_test/os_interface/linux/drm_query_topology_prelim_tests.cpp

@@ -96,7 +96,7 @@ struct QueryTopologyTests : ::testing::Test {
         multiTileArch.TileCount = tileCount;
         multiTileArch.TileMask = static_cast<uint8_t>(maxNBitValue(tileCount));
 
-        drmMock = std::make_unique<MyDrmQueryMock>(*rootDeviceEnvironment, rootDeviceEnvironment->getHardwareInfo());
+        drmMock = std::make_unique<MyDrmQueryMock>(*rootDeviceEnvironment);
 
         drmMock->storedSVal = 8;
         drmMock->storedSSVal = 32;

shared/test/unit_test/os_interface/linux/drm_system_info_tests.cpp

@@ -21,10 +21,11 @@ TEST(DrmSystemInfoTest, whenQueryingSystemInfoThenSystemInfoIsNotCreatedAndIoctl
     auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
     DrmMock drm(*executionEnvironment->rootDeviceEnvironments[0]);
 
+    auto ioctlCount = drm.ioctlCount.total.load();
     EXPECT_FALSE(drm.querySystemInfo());
 
     EXPECT_EQ(nullptr, drm.getSystemInfo());
-    EXPECT_EQ(1u + drm.getBaseIoctlCalls(), drm.ioctlCallsCount);
+    EXPECT_EQ(1 + ioctlCount, drm.ioctlCount.total.load());
 }
 
 TEST(DrmSystemInfoTest, givenSystemInfoCreatedWhenQueryingSpecificAtrributesThenReturnZero) {

shared/test/unit_test/os_interface/linux/drm_with_prelim_tests.cpp

@@ -5,7 +5,7 @@
  *
  */
 
-#include "shared/source/os_interface/linux/i915.h"
+#include "shared/source/os_interface/linux/i915_prelim.h"
 #include "shared/source/os_interface/linux/ioctl_helper.h"
 #include "shared/source/os_interface/linux/os_context_linux.h"
 #include "shared/test/common/helpers/debug_manager_state_restore.h"
@@ -23,11 +23,7 @@ extern int handlePrelimRequests(DrmIoctl request, void *arg, int ioctlRetVal, in
 
 class DrmPrelimMock : public DrmMock {
   public:
-    DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment) : DrmPrelimMock(rootDeviceEnvironment, defaultHwInfo.get()) {}
+    using DrmMock::DrmMock;
-    DrmPrelimMock(RootDeviceEnvironment &rootDeviceEnvironment, HardwareInfo *inputHwInfo) : DrmMock(rootDeviceEnvironment) {
-        rootDeviceEnvironment.setHwInfo(inputHwInfo);
-        rootDeviceEnvironment.getMutableHardwareInfo()->platform.eProductFamily = IGFX_UNKNOWN;
-    }
 
     int ioctlRetVal = 0;
     int queryDistanceIoctlRetVal = 0;
@@ -37,6 +33,30 @@ class DrmPrelimMock : public DrmMock {
     }
 
     int handleRemainingRequests(DrmIoctl request, void *arg) override {
+        if (request == DrmIoctl::Query && arg != nullptr) {
+            auto queryArg = static_cast<Query *>(arg);
+            for (auto i = 0u; i < queryArg->numItems; i++) {
+                auto queryItemArg = (reinterpret_cast<QueryItem *>(queryArg->itemsPtr) + i);
+                if (queryItemArg->queryId == PRELIM_DRM_I915_QUERY_HW_IP_VERSION) {
+                    ioctlCallsCount--;
+                    if (queryItemArg->length == 0) {
+                        queryItemArg->length = static_cast<int32_t>(sizeof(prelim_drm_i915_query_hw_ip_version));
+                        if (this->returnInvalidHwIpVersionLength) {
+                            queryItemArg->length -= 1;
+                        }
+                    } else {
+                        if (this->failRetHwIpVersion) {
+                            return EINVAL;
+                        }
+                        auto hwIpVersion = reinterpret_cast<prelim_drm_i915_query_hw_ip_version *>(queryItemArg->dataPtr);
+                        hwIpVersion->stepping = 1;
+                        hwIpVersion->release = 2;
+                        hwIpVersion->arch = 3;
+                    }
+                    return 0;
+                }
+            }
+        }
         return handlePrelimRequests(request, arg, ioctlRetVal, queryDistanceIoctlRetVal);
     }
 };
@@ -493,3 +513,56 @@ TEST_F(IoctlHelperPrelimFixture, givenProgramDebuggingAndContextDebugSupportedWh
     EXPECT_NE(static_cast<uint32_t>(-1), drm->passedContextDebugId);
     EXPECT_TRUE(drm->capturedCooperativeContextRequest);
 }
+
+TEST_F(IoctlHelperPrelimFixture, givenIoctlHelperWhenInitializatedThenIpVersionIsSet) {
+    auto &ipVersion = executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo()->ipVersion;
+    ipVersion = {};
+    EXPECT_TRUE(drm->ioctlHelper->initialize());
+    EXPECT_EQ(ipVersion.revision, 1u);
+    EXPECT_EQ(ipVersion.release, 2u);
+    EXPECT_EQ(ipVersion.architecture, 3u);
+}
+
+TEST_F(IoctlHelperPrelimFixture, givenIoctlHelperWhenFailOnInitializationThenIpVersionIsNotSet) {
+    auto &ipVersion = executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo()->ipVersion;
+    ipVersion = {};
+    drm->failRetHwIpVersion = true;
+    EXPECT_FALSE(drm->ioctlHelper->initialize());
+
+    EXPECT_EQ(ipVersion.revision, 0u);
+    EXPECT_EQ(ipVersion.release, 0u);
+    EXPECT_EQ(ipVersion.architecture, 0u);
+}
+
+TEST_F(IoctlHelperPrelimFixture, givenIoctlHelperWhenInvalidHwIpVersionSizeOnInitializationThenErrorIsPrinted) {
+    DebugManagerStateRestore restore;
+    DebugManager.flags.PrintDebugMessages.set(true);
+
+    testing::internal::CaptureStderr();
+    drm->returnInvalidHwIpVersionLength = true;
+    EXPECT_FALSE(drm->ioctlHelper->initialize());
+
+    DebugManager.flags.PrintDebugMessages.set(false);
+    std::string output = testing::internal::GetCapturedStderr();
+    std::string expectedOutput = "Size got from PRELIM_DRM_I915_QUERY_HW_IP_VERSION query does not match PrelimI915::prelim_drm_i915_query_hw_ip_version size\n";
+
+    EXPECT_STREQ(output.c_str(), expectedOutput.c_str());
+}
+
+TEST_F(IoctlHelperPrelimFixture, givenIoctlHelperWhenFailOnInitializationAndPlatformQueryIsSupportedThenErrorIsPrinted) {
+    DebugManagerStateRestore restore;
+    DebugManager.flags.PrintDebugMessages.set(true);
+
+    testing::internal::CaptureStderr();
+    drm->failRetHwIpVersion = true;
+    EXPECT_FALSE(drm->ioctlHelper->initialize());
+
+    DebugManager.flags.PrintDebugMessages.set(false);
+    std::string output = testing::internal::GetCapturedStderr();
+
+    if (HwInfoConfig::get(executionEnvironment->rootDeviceEnvironments[0]->getHardwareInfo()->platform.eProductFamily)->isPlatformQuerySupported()) {
+        EXPECT_STRNE(output.c_str(), "");
+    } else {
+        EXPECT_STREQ(output.c_str(), "");
+    }
+}

shared/test/unit_test/os_interface/linux/ioctl_helper_prelim_init_tests.cpp

@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2022 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "shared/source/os_interface/linux/ioctl_helper.h"
-#include "shared/test/common/libult/linux/drm_mock.h"
-#include "shared/test/common/mocks/mock_execution_environment.h"
-#include "shared/test/common/test_macros/test.h"
-
-using namespace NEO;
-
-TEST(IoctlHelperPrelimInitializationTests, givenPrelimWhenInitializingThenTrueIsReturned) {
-    auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
-    auto drm = std::make_unique<DrmMock>(*executionEnvironment->rootDeviceEnvironments[0]);
-    ASSERT_NE(nullptr, drm);
-
-    IoctlHelperPrelim20 ioctlHelper{*drm};
-    EXPECT_EQ(true, ioctlHelper.initialize());
-}