feature: Map PMT interface correctly on multi GPU system

Related-To: NEO-15912 Signed-off-by: shubham kumar <shubham.kumar@intel.com>
2025-12-29 09:03:14 +08:00 · 2025-10-09 11:38:58 +00:00
parent 226846323f
commit 7a97b98cfe
22 changed files with 933 additions and 267 deletions
--- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp
+++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp
@@ -162,24 +162,162 @@ ze_result_t PlatformMonitoringTech::init() {
    return result;
 }

-std::unique_ptr<PlatformMonitoringTech> PlatformMonitoringTech::create(SysmanProductHelper *pSysmanProductHelper) {
-    std::wstring deviceInterface;
-    if (enumeratePMTInterface(&PmtSysman::GuidInterfacePmtTelemetry, deviceInterface) == ZE_RESULT_SUCCESS) {
-        std::unique_ptr<PlatformMonitoringTech> pPmt;
-        pPmt = std::make_unique<PlatformMonitoringTech>(deviceInterface, pSysmanProductHelper);
-        UNRECOVERABLE_IF(nullptr == pPmt);
-        if (pPmt->init() != ZE_RESULT_SUCCESS) {
-            pPmt.reset(nullptr);
-        }
-        return pPmt;
+std::unique_ptr<PlatformMonitoringTech> PlatformMonitoringTech::create(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) {
+    std::unique_ptr<PlatformMonitoringTech> pPmt;
+    pPmt = std::make_unique<PlatformMonitoringTech>(pSysmanProductHelper, bus, device, function);
+    UNRECOVERABLE_IF(nullptr == pPmt);
+
+    if ((pPmt->getDeviceInterface() != ZE_RESULT_SUCCESS) || (pPmt->init() != ZE_RESULT_SUCCESS)) {
+        pPmt.reset(nullptr);
+        return nullptr;
    }
-    return nullptr;
+    return pPmt;
 }

 PlatformMonitoringTech::~PlatformMonitoringTech() {
 }

-ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std::wstring &deviceInterface) {
+ze_result_t PlatformMonitoringTech::getDeviceRegistryProperty(HDEVINFO deviceInfoSet, SP_DEVINFO_DATA *pDeviceInfoData, DWORD devicePropertyType, std::vector<uint8_t> &dataBuffer) {
+
+    DWORD dataSizeInBytes;
+
+    if (NEO::SysCalls::setupDiGetDeviceRegistryProperty(deviceInfoSet, pDeviceInfoData, devicePropertyType, nullptr, nullptr, 0, &dataSizeInBytes)) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    dataBuffer.resize(dataSizeInBytes);
+    if (!NEO::SysCalls::setupDiGetDeviceRegistryProperty(deviceInfoSet, pDeviceInfoData, devicePropertyType, nullptr, dataBuffer.data(), (DWORD)dataBuffer.size(), nullptr)) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+bool PlatformMonitoringTech::isInstancePciBdfMatchingWithWddmDevice(HDEVINFO hDevInfo, SP_DEVINFO_DATA *pDeviceInfoData) {
+    std::vector<uint8_t> dataBuffer;
+    uint32_t devicePciBus = 0;
+    uint32_t devicePciDevice = 0;
+    uint32_t devicePciFunction = 0;
+
+    // Fetch device pci bus number
+    ze_result_t result = getDeviceRegistryProperty(hDevInfo, pDeviceInfoData, SPDRP_BUSNUMBER, dataBuffer);
+    if (result != ZE_RESULT_SUCCESS) {
+        return false;
+    }
+
+    memcpy_s(&devicePciBus, sizeof(uint32_t), dataBuffer.data(), sizeof(uint8_t) * dataBuffer.size());
+
+    if (devicePciBus != this->pciBus) {
+        return false;
+    }
+
+    dataBuffer.resize(0);
+    uint32_t deviceAddress = 0;
+
+    // Fetch device pci address. This provides the pci device and function numbers
+    result = getDeviceRegistryProperty(hDevInfo, pDeviceInfoData, SPDRP_ADDRESS, dataBuffer);
+    if (result != ZE_RESULT_SUCCESS) {
+        return false;
+    }
+
+    memcpy_s(&deviceAddress, sizeof(uint32_t), dataBuffer.data(), sizeof(uint8_t) * dataBuffer.size());
+    devicePciDevice = (deviceAddress >> 16) & 0xffff;
+    devicePciFunction = deviceAddress & 0xffff;
+
+    if ((devicePciDevice != this->pciDevice) || (devicePciFunction != this->pciFunction)) {
+        return false;
+    }
+
+    return true;
+}
+
+ze_result_t PlatformMonitoringTech::getDeviceInstanceId(DEVINST deviceInstance, std::wstring &deviceInstanceId) {
+    unsigned long dataSizeInBytes = 0;
+
+    CONFIGRET result = NEO::SysCalls::cmGetDeviceIdSize(&dataSizeInBytes, deviceInstance, 0);
+    if (result != CR_SUCCESS) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    std::vector<wchar_t> dataBuffer(dataSizeInBytes + 1, 0);
+    result = NEO::SysCalls::cmGetDeviceId(deviceInstance, dataBuffer.data(), (ULONG)dataBuffer.size(), 0);
+    if (result != CR_SUCCESS) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    deviceInstanceId = std::wstring(dataBuffer.begin(), dataBuffer.end() - 1);
+    return ZE_RESULT_SUCCESS;
+}
+
+void PlatformMonitoringTech::getAllChildDeviceInterfaces(HDEVINFO hDevInfo, DEVINST deviceInstance, uint32_t level, std::vector<std::wstring> &deviceInstanceIdList) {
+
+    // According to Microsoft's guide we need to follow the below steps to find all the children for a device instance.
+    // Call the CM_Get_Child function to retrieve a device instance handle to the first child device that is associated with a device instance.
+    // Call CM_Get_Sibling as many times as it is necessary to enumerate all the sibling devices of the first child device that was retrieved by the call to CM_Get_Child.
+    // Call CM_Get_Device_ID to retrieve the device instance identifiers that are associated with the device instance handles that were returned by the calls to CM_Get_Child and CM_Get_Sibling.
+
+    std::wstring deviceInstanceId;
+    if ((getDeviceInstanceId(deviceInstance, deviceInstanceId) != ZE_RESULT_SUCCESS) || deviceInstanceId.empty()) {
+        return;
+    }
+
+    if (level > 1) {
+        deviceInstanceIdList.push_back(deviceInstanceId);
+    }
+
+    // Get the SP_DEVINFO_DATA for the device
+    SP_DEVINFO_DATA deviceInfoData = {};
+    deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
+    if (!NEO::SysCalls::setupDiOpenDeviceInfo(hDevInfo, deviceInstanceId.c_str(), nullptr, 0, &deviceInfoData)) {
+        return;
+    }
+
+    DEVINST childDeviceInstance = 0;
+    if (NEO::SysCalls::cmGetChild(&childDeviceInstance, deviceInstance, 0) == CR_SUCCESS) {
+        getAllChildDeviceInterfaces(hDevInfo, childDeviceInstance, level + 1, deviceInstanceIdList);
+
+        DEVINST siblingDeviceInstance;
+        while (NEO::SysCalls::cmGetSibling(&siblingDeviceInstance, childDeviceInstance, 0) == CR_SUCCESS) {
+            getAllChildDeviceInterfaces(hDevInfo, siblingDeviceInstance, level + 1, deviceInstanceIdList);
+            childDeviceInstance = siblingDeviceInstance;
+        }
+    }
+}
+
+ze_result_t PlatformMonitoringTech::getDeviceInterface() {
+    std::wstring pmtDeviceInstanceId;
+    GUID displayAdapter = PmtSysman::GuidIntefaceDisplayAdapter;
+    GUID pmtTelemetry = PmtSysman::GuidIntefacePmtTelemetry;
+
+    HDEVINFO hDevInfo = NEO::SysCalls::setupDiGetClassDevs(&displayAdapter, NULL, NULL, DIGCF_PRESENT);
+    if (hDevInfo == INVALID_HANDLE_VALUE) {
+        DEBUG_BREAK_IF(true);
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
+
+    SP_DEVINFO_DATA deviceInfoData = {};
+    deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
+    for (DWORD i = 0; NEO::SysCalls::setupDiEnumDeviceInfo(hDevInfo, i, &deviceInfoData); i++) {
+        if (isInstancePciBdfMatchingWithWddmDevice(hDevInfo, &deviceInfoData)) {
+            std::vector<std::wstring> deviceInstanceIdList;
+
+            // Get all child devices
+            getAllChildDeviceInterfaces(hDevInfo, deviceInfoData.DevInst, 1, deviceInstanceIdList);
+
+            // Find the PMT device instance ID
+            for (auto &deviceInstanceId : deviceInstanceIdList) {
+                if (deviceInstanceId.find(L"INTC_PMT") != std::wstring::npos) {
+                    pmtDeviceInstanceId = deviceInstanceId;
+                    break;
+                }
+            }
+            break;
+        }
+    }
+
+    if (NEO::SysCalls::setupDiDestroyDeviceInfoList(hDevInfo) == FALSE) {
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }

    unsigned long cmListCharCount = 0;
    CONFIGRET status = CR_SUCCESS;
@@ -188,7 +326,7 @@ ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std:
    do {
        // Get the total size of list of all instances
        // N.B. Size returned is total length in "characters"
-        status = NEO::SysCalls::cmGetDeviceInterfaceListSize(&cmListCharCount, (LPGUID)guid, NULL, CM_GET_DEVICE_INTERFACE_LIST_PRESENT);
+        status = NEO::SysCalls::cmGetDeviceInterfaceListSize(&cmListCharCount, (LPGUID)&pmtTelemetry, &pmtDeviceInstanceId[0], CM_GET_DEVICE_INTERFACE_LIST_PRESENT);

        if (status != CR_SUCCESS) {
            break;
@@ -207,7 +345,7 @@ ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std:
            return ZE_RESULT_ERROR_UNKNOWN;
        }
        // N.B. cmListCharCount is length in characters
-        status = NEO::SysCalls::cmGetDeviceInterfaceList((LPGUID)guid, NULL, deviceInterfaceList.data(), cmListCharCount, CM_GET_DEVICE_INTERFACE_LIST_PRESENT);
+        status = NEO::SysCalls::cmGetDeviceInterfaceList((LPGUID)&pmtTelemetry, &pmtDeviceInstanceId[0], deviceInterfaceList.data(), cmListCharCount, CM_GET_DEVICE_INTERFACE_LIST_PRESENT);
    } while (status == CR_BUFFER_SMALL);

    if (status != CR_SUCCESS) {
--- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h
+++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h
@@ -26,19 +26,24 @@ class SysmanProductHelper;
 class PlatformMonitoringTech : NEO::NonCopyableAndNonMovableClass {
  public:
    PlatformMonitoringTech() = delete;
-    PlatformMonitoringTech(std::wstring deviceInterface, SysmanProductHelper *pSysmanProductHelper) : deviceInterface(std::move(deviceInterface)), pSysmanProductHelper(pSysmanProductHelper) {}
+    PlatformMonitoringTech(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) : pSysmanProductHelper(pSysmanProductHelper), pciBus(bus), pciDevice(device), pciFunction(function) {}
    virtual ~PlatformMonitoringTech();

    virtual ze_result_t readValue(const std::string &key, uint32_t &value);
    virtual ze_result_t readValue(const std::string &key, uint64_t &value);
    ze_result_t getKeyOffsetMap(std::map<std::string, std::pair<uint32_t, uint32_t>> &keyOffsetMap);
-    static std::unique_ptr<PlatformMonitoringTech> create(SysmanProductHelper *pSysmanProductHelper);
-    static ze_result_t enumeratePMTInterface(const GUID *Guid, std::wstring &deviceInterface);
+    static std::unique_ptr<PlatformMonitoringTech> create(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function);

  protected:
+    std::wstring deviceInterface;
    std::map<std::string, std::pair<uint32_t, uint32_t>> keyOffsetMap;
    unsigned long guidToIndexList[PmtSysman::PmtMaxInterfaces] = {0};
    ze_result_t ioctlReadWriteData(std::wstring &path, uint32_t ioctl, void *bufferIn, uint32_t inSize, void *bufferOut, uint32_t outSize, uint32_t *sizeReturned);
+    ze_result_t getDeviceInterface();
+    ze_result_t getDeviceRegistryProperty(HDEVINFO deviceInfoSet, SP_DEVINFO_DATA *pDeviceInfoData, DWORD devicePropertyType, std::vector<uint8_t> &dataBuffer);
+    bool isInstancePciBdfMatchingWithWddmDevice(HDEVINFO hDevInfo, SP_DEVINFO_DATA *pDeviceInfoData);
+    ze_result_t getDeviceInstanceId(DEVINST deviceInstance, std::wstring &deviceInstanceId);
+    void getAllChildDeviceInterfaces(HDEVINFO hDevInfo, DEVINST deviceInstance, uint32_t level, std::vector<std::wstring> &interfacePathList);
    virtual ze_result_t init();
    ze_result_t getGuid();
    decltype(&NEO::SysCalls::deviceIoControl) pdeviceIoControl = NEO::SysCalls::deviceIoControl;
@@ -48,9 +53,11 @@ class PlatformMonitoringTech : NEO::NonCopyableAndNonMovableClass {
    decltype(&NEO::SysCalls::heapFree) heapFreeFunction = NEO::SysCalls::heapFree;

  private:
-    std::wstring deviceInterface;
    SysmanProductHelper *pSysmanProductHelper = nullptr;
    uint32_t baseOffset = 0;
+    uint32_t pciBus;
+    uint32_t pciDevice;
+    uint32_t pciFunction;
 };

 } // namespace Sysman
--- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h
+++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h
@@ -20,7 +20,8 @@ constexpr uint32_t MethodBuffered = 0;
 constexpr uint32_t FileReadAccess = 0x0001;

 // Intel PMT Telemetry Interface GUID {3dfb2563-5c44-4c59-8d80-baea7d06e6b8}
-constexpr GUID GuidInterfacePmtTelemetry = {0x3dfb2563, 0x5c44, 0x4c59, {0x8d, 0x80, 0xba, 0xea, 0x7d, 0x06, 0xe6, 0xb8}};
+constexpr GUID GuidIntefacePmtTelemetry = {0x3dfb2563, 0x5c44, 0x4c59, {0x8d, 0x80, 0xba, 0xea, 0x7d, 0x06, 0xe6, 0xb8}};
+constexpr GUID GuidIntefaceDisplayAdapter = {0x4d36e968, 0xe325, 0x11ce, {0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18}};

 inline constexpr uint32_t getCtlCode(uint32_t code) {
    return CTL_CODE(FileDeviceIntelPmt, code, MethodBuffered, FileReadAccess);
--- a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp
+++ b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp
@@ -52,7 +52,8 @@ ze_result_t WddmSysmanImp::init() {
        }
    }

-    pPmt = PlatformMonitoringTech::create(pSysmanProductHelper.get());
+    pciBusInfo = pParentSysmanDeviceImp->getRootDeviceEnvironment().osInterface->getDriverModel()->getPciBusInfo();
+    pPmt = PlatformMonitoringTech::create(pSysmanProductHelper.get(), pciBusInfo.pciBus, pciBusInfo.pciDevice, pciBusInfo.pciFunction);
    return ZE_RESULT_SUCCESS;
 }

@@ -74,7 +75,6 @@ PlatformMonitoringTech *WddmSysmanImp::getSysmanPmt() {
 }

 void WddmSysmanImp::createFwUtilInterface() {
-    const auto pciBusInfo = pParentSysmanDeviceImp->getRootDeviceEnvironment().osInterface->getDriverModel()->getPciBusInfo();
    const uint16_t domain = static_cast<uint16_t>(pciBusInfo.pciDomain);
    const uint8_t bus = static_cast<uint8_t>(pciBusInfo.pciBus);
    const uint8_t device = static_cast<uint8_t>(pciBusInfo.pciDevice);
--- a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h
+++ b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h
@@ -62,6 +62,7 @@ class WddmSysmanImp : public OsSysman, NEO::NonCopyableAndNonMovableClass {
    } uuid;

  private:
+    NEO::PhysicalDevicePciBusInfo pciBusInfo;
    SysmanDeviceImp *pParentSysmanDeviceImp = nullptr;
    NEO::Wddm *pWddm = nullptr;
    uint32_t subDeviceCount = 0;
--- a/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h
+++ b/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h
@@ -11,7 +11,6 @@

 #include "level_zero/sysman/source/api/memory/sysman_memory_imp.h"
 #include "level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h"
-#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h"
 #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h"
 #include "level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory_manager.h"
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"
@@ -205,12 +204,6 @@ class PublicWddmPowerImp : public L0::Sysman::WddmMemoryImp {
    using WddmMemoryImp::pKmdSysManager;
 };

-class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
-  public:
-    PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {}
-    using PlatformMonitoringTech::keyOffsetMap;
-};
-
 struct MockSysmanProductHelperMemory : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
    MockSysmanProductHelperMemory() = default;
    ADDMETHOD_NOBASE(getMemoryBandWidth, ze_result_t, ZE_RESULT_SUCCESS, (zes_mem_bandwidth_t * pBandwidth, WddmSysmanImp *pWddmSysmanImp));
--- a/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h
+++ b/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h
@@ -8,7 +8,6 @@
 #pragma once
 #include "level_zero/sysman/source/api/pci/sysman_pci_imp.h"
 #include "level_zero/sysman/source/api/pci/windows/sysman_os_pci_imp.h"
-#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h"
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"

 namespace L0 {
@@ -125,12 +124,6 @@ struct PciKmdSysManager : public MockKmdSysManager {
    }
 };

-class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
-  public:
-    PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {}
-    using PlatformMonitoringTech::keyOffsetMap;
-};
-
 class PciWddmSysmanImp : public L0::Sysman::WddmSysmanImp {
  public:
    PciWddmSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp) : WddmSysmanImp(pParentSysmanDeviceImp) {}
@@ -163,6 +156,7 @@ class PciWddmSysmanImp : public L0::Sysman::WddmSysmanImp {
        return pPciBdfInfo;
    }
 };
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0
--- a/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp
@@ -31,12 +31,11 @@ const std::map<std::string, std::pair<uint32_t, uint32_t>> dummyKeyOffsetMap = {
     {"GDDR_TELEM_CAPTURE_TIMESTAMP_UPPER", {92, 1}},
     {"GDDR_TELEM_CAPTURE_TIMESTAMP_LOWER", {93, 1}}}};

-const std::wstring deviceInterfacePci = L"TEST\0";
-
 class SysmanDevicePciFixture : public SysmanDeviceFixture {
  protected:
    std::unique_ptr<PciKmdSysManager> pKmdSysManager = nullptr;
    KmdSysManager *pOriginalKmdSysManager = nullptr;
+    PublicPlatformMonitoringTech *pPmt = nullptr;
    void SetUp() override {

        SysmanDeviceFixture::SetUp();
@@ -46,8 +45,9 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture {
        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
        pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();

-        auto pPmt = new PublicPlatformMonitoringTech(deviceInterfacePci, pWddmSysmanImp->getSysmanProductHelper());
+        pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
        pPmt->keyOffsetMap = dummyKeyOffsetMap;
+        pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
        pWddmSysmanImp->pPmt.reset(pPmt);

        delete pSysmanDeviceImp->pPci;
--- a/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h
+++ b/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h
@@ -7,7 +7,6 @@

 #pragma once

-#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h"
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"

 namespace L0 {
@@ -226,12 +225,6 @@ struct PowerKmdSysManager : public MockKmdSysManager {
    }
 };

-class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
-  public:
-    PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {}
-    using PlatformMonitoringTech::keyOffsetMap;
-};
-
 } // namespace ult
 } // namespace Sysman
 } // namespace L0
--- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp
@@ -63,11 +63,11 @@ const std::map<std::string, std::pair<uint32_t, uint32_t>> dummyKeyOffsetMap = {
     {"GDDR0_CH1_GT_64B_WR_REQ_UPPER", {120, 1}},
     {"GDDR0_CH1_GT_64B_WR_REQ_LOWER", {121, 1}}}};

-const std::wstring deviceInterfaceMemory = L"TEST\0";
 class SysmanDeviceMemoryHelperFixture : public SysmanDeviceFixture {
  protected:
    std::unique_ptr<MockMemoryKmdSysManager> pKmdSysManager;
    L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
+    PublicPlatformMonitoringTech *pPmt = nullptr;

    void SetUp() override {
        SysmanDeviceFixture::SetUp();
@@ -79,8 +79,9 @@ class SysmanDeviceMemoryHelperFixture : public SysmanDeviceFixture {
        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
        pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();

-        auto pPmt = new PublicPlatformMonitoringTech(deviceInterfaceMemory, pWddmSysmanImp->getSysmanProductHelper());
+        pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
        pPmt->keyOffsetMap = dummyKeyOffsetMap;
+        pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
        pWddmSysmanImp->pPmt.reset(pPmt);

        pSysmanDeviceImp->pMemoryHandleContext->handleList.clear();
--- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp
@@ -18,8 +18,6 @@ namespace L0 {
 namespace Sysman {
 namespace ult {

-const std::wstring pmtInterfacePower = L"TEST\0";
-
 const std::map<std::string, std::pair<uint32_t, uint32_t>> dummyKeyOffsetMap = {
    {{"XTAL_CLK_FREQUENCY", {1, 0}},
     {"XTAL_COUNT", {128, 0}},
@@ -46,6 +44,7 @@ class SysmanProductHelperPowerTest : public SysmanDeviceFixture {
  protected:
    std::unique_ptr<PowerKmdSysManager> pKmdSysManager;
    L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
+    PublicPlatformMonitoringTech *pPmt = nullptr;

    void SetUp() override {
        SysmanDeviceFixture::SetUp();
@@ -61,15 +60,9 @@ class SysmanProductHelperPowerTest : public SysmanDeviceFixture {
            delete handle;
        }

-        auto pPmt = new PublicPlatformMonitoringTech(pmtInterfacePower, pWddmSysmanImp->getSysmanProductHelper());
+        pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
        pPmt->keyOffsetMap = dummyKeyOffsetMap;
-        pWddmSysmanImp->pPmt.reset(pPmt);
-        pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
-    }
-
-    void updatePmtKeyOffsetMap(const std::map<std::string, std::pair<uint32_t, uint32_t>> keyOffsetMap) {
-        auto pPmt = new PublicPlatformMonitoringTech(pmtInterfacePower, pWddmSysmanImp->getSysmanProductHelper());
-        pPmt->keyOffsetMap = keyOffsetMap;
+        pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
        pWddmSysmanImp->pPmt.reset(pPmt);
        pSysmanDeviceImp->pPowerHandleContext->handleList.clear();
    }
@@ -188,7 +181,7 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenGettingPowerEne
    });
    // Setting allow set calls or not
    init(true);
-    updatePmtKeyOffsetMap(dummyKeyOffsetMapToGetEnergyCounterFromPunit);
+    pPmt->keyOffsetMap = dummyKeyOffsetMapToGetEnergyCounterFromPunit;

    // Calculate the expected energy counter value from the mockPmtEnergyCounterVariableFromOobmsmBackupValue
    uint32_t integerPart = static_cast<uint32_t>(mockPmtEnergyCounterVariableFromOobmsmBackupValue >> 14);
--- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp
@@ -17,7 +17,6 @@ namespace L0 {
 namespace Sysman {
 namespace ult {

-std::wstring pmtInterface = std::move(pmtInterfaceName);
 const std::map<std::string, std::pair<uint32_t, uint32_t>> dummyKeyOffsetMap = {
    {{"SOC_THERMAL_SENSORS_TEMPERATURE_0_2_0_GTTMMADR[1]", {41, 1}},
     {"VRAM_TEMPERATURE_0_2_0_GTTMMADR", {42, 1}}}};
@@ -28,6 +27,7 @@ class SysmanProductHelperTemperatureTest : public SysmanDeviceFixture {
    std::unique_ptr<TemperatureKmdSysManager> pKmdSysManager = nullptr;
    L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
    std::vector<ze_device_handle_t> deviceHandles;
+    PublicPlatformMonitoringTech *pPmt = nullptr;
    void SetUp() override {
        SysmanDeviceFixture::SetUp();

@@ -36,8 +36,10 @@ class SysmanProductHelperTemperatureTest : public SysmanDeviceFixture {

        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
        pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();
-        auto pPmt = new PublicPlatformMonitoringTech(pmtInterface, pWddmSysmanImp->getSysmanProductHelper());
+
+        pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
        pPmt->keyOffsetMap = dummyKeyOffsetMap;
+        pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
        pWddmSysmanImp->pPmt.reset(pPmt);

        pSysmanDeviceImp->pTempHandleContext->handleList.clear();
--- a/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h
+++ b/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h
@@ -10,7 +10,6 @@
 #include "shared/test/common/test_macros/mock_method_macros.h"

 #include "level_zero/sysman/source/api/temperature/sysman_temperature_imp.h"
-#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h"
 #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h"
 #include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h"
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h"
@@ -19,7 +18,6 @@ namespace L0 {
 namespace Sysman {
 namespace ult {

-const std::wstring pmtInterfaceName = L"TEST\0";
 constexpr uint32_t temperatureHandleComponentCount = 3u;

 struct TemperatureKmdSysManager : public MockKmdSysManager {
@@ -99,12 +97,6 @@ struct TemperatureKmdSysManager : public MockKmdSysManager {
    }
 };

-class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
-  public:
-    PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {}
-    using PlatformMonitoringTech::keyOffsetMap;
-};
-
 struct MockSysmanProductHelperTemp : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
    MockSysmanProductHelperTemp() = default;
    ADDMETHOD_NOBASE(getSensorTemperature, ze_result_t, ZE_RESULT_SUCCESS, (double *pTemperature, zes_temp_sensors_t type, WddmSysmanImp *pWddmSysmanImp));
--- a/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp
@@ -20,7 +20,6 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
    L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr;
    std::vector<ze_device_handle_t> deviceHandles;
    void SetUp() override {
-        std::wstring deviceInterfacePmt = std::move(pmtInterfaceName);
        SysmanDeviceFixture::SetUp();

        pKmdSysManager.reset(new TemperatureKmdSysManager);
@@ -29,7 +28,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
        pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager;
        pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get();

-        auto pPmt = new PublicPlatformMonitoringTech(deviceInterfacePmt, pWddmSysmanImp->getSysmanProductHelper());
+        auto pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
        pWddmSysmanImp->pPmt.reset(pPmt);

        pSysmanDeviceImp->pTempHandleContext->handleList.clear();
--- a/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h
+++ b/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -14,6 +14,7 @@
 #include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h"
 #include "level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h"
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_wddm.h"
+#include "level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h"

 #include "gtest/gtest.h"

--- a/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h
+++ b/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h
@@ -15,9 +15,12 @@ namespace L0 {
 namespace Sysman {
 namespace ult {

+const std::wstring deviceInterface = L"TEST_INTC_PMT\0";
+
 class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
  public:
-    PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {}
+    PublicPlatformMonitoringTech(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) : PlatformMonitoringTech(pSysmanProductHelper, bus, device, function) {}
+    using PlatformMonitoringTech::deviceInterface;
    using PlatformMonitoringTech::keyOffsetMap;
    using PlatformMonitoringTech::pcreateFile;
    using PlatformMonitoringTech::pdeviceIoControl;
--- a/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp
@@ -16,7 +16,10 @@ namespace L0 {
 namespace Sysman {
 namespace ult {

-const std::wstring deviceInterface = L"TEST_INTC_PMT\0";
+static uint32_t sysCallsCmGetChildCount = 1;
+static uint32_t sysCallsCmGetSiblingCount = 1;
+static uint32_t createCallCount = 2;
+static int sysCallsInterfaceListCounter = 0;

 const std::map<std::string, std::pair<uint32_t, uint32_t>> dummyKeyOffsetMap = {
    {"DUMMY_KEY", {0x0, 1}}};
@@ -31,13 +34,86 @@ inline static BOOL mockDeviceIoControlSuccess(HANDLE hDevice, DWORD dwIoControlC
    return true;
 }

+inline static BOOL mockDeviceIoControlExtendedSuccess(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) {
+    if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
+        *static_cast<unsigned long *>(lpOutBuffer) = 40;
+    } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
+        PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
+        *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
+    }
+    return true;
+}
+
+inline static CONFIGRET mockCmGetDeviceInterfaceListSizeSuccess(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) {
+    if (pDeviceID[0] != L'\0') {
+        *pulLen = 40;
+        return CR_SUCCESS;
+    }
+    return CR_FAILURE;
+}
+
+inline static CONFIGRET mockCmGetDeviceInterfaceListSuccess(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) {
+    wcscpy(buffer, L"TEST_INTC_PMT");
+    return CR_SUCCESS;
+}
+
+inline static CONFIGRET mockCmGetDeviceIdSizeSuccess(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) {
+    *pulLen = 40;
+    return CR_SUCCESS;
+}
+
+inline static CONFIGRET mockCmGetDeviceIdSuccess(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) {
+    wcscpy(buffer, L"TEST_INTC_PMT");
+    return CR_SUCCESS;
+}
+
+inline static BOOL mockSetupDiGetDeviceRegistryPropertySuccess(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) {
+    if (requiredSize != nullptr) {
+        *requiredSize = 0x1;
+        return false;
+    }
+    *propertyBuffer = 0u;
+    return true;
+}
+
+inline static CONFIGRET mockCmGetChildSuccess(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    if (sysCallsCmGetChildCount) {
+        sysCallsCmGetChildCount--;
+        return CR_SUCCESS;
+    }
+    return CR_FAILURE;
+}
+
+inline static CONFIGRET mockCmGetSiblingSuccess(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    if (sysCallsCmGetSiblingCount) {
+        sysCallsCmGetSiblingCount--;
+        return CR_SUCCESS;
+    }
+    return CR_FAILURE;
+}
+
+inline static BOOL mockSetupDiEnumDeviceInfoSuccess(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) {
+    return true;
+}
+
+inline static BOOL mockSetupDiOpenDeviceInfoSuccess(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) {
+    return true;
+}
+
+inline static BOOL mockSetupDiDestroyDeviceInfoListSuccess(HDEVINFO deviceInfoSet) {
+    return true;
+}
+
+inline static HDEVINFO mockSetupDiGetClassDevsSuccess(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) {
+    return reinterpret_cast<HDEVINFO>(static_cast<uintptr_t>(0x1));
+}
+
 class SysmanDevicePmtFixture : public SysmanDeviceFixture {
  protected:
    std::unique_ptr<PublicPlatformMonitoringTech> pPmt;
    void SetUp() override {
        SysmanDeviceFixture::SetUp();
-        std::wstring deviceInterface;
-        pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+        pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    }

    void TearDown() override {
@@ -46,13 +122,11 @@ class SysmanDevicePmtFixture : public SysmanDeviceFixture {
 };

 TEST_F(SysmanDevicePmtFixture, GivenWrongKeyWhenCallingReadValueWithUint32TypeThenCallFails) {
-
    uint32_t val = 0;
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("SOMETHING", val));
 }

 TEST_F(SysmanDevicePmtFixture, GivenWrongKeyWhenCallingReadValueWithUint64TypeThenCallFails) {
-
    uint64_t val = 0;
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("SOMETHING", val));
 }
@@ -67,7 +141,8 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtHandleWhenCallingReadValue32CallFa
    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
        return INVALID_HANDLE_VALUE;
    });
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    uint32_t val = 0;
    pPmt->keyOffsetMap = dummyKeyOffsetMap;
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
@@ -77,22 +152,25 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtHandleWhenCallingReadValue64CallFa
    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
        return INVALID_HANDLE_VALUE;
    });
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    uint64_t val = 0;
    pPmt->keyOffsetMap = dummyKeyOffsetMap;
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
 }

 TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32WhenIoctlCallFailsThenProperErrorIsReturned) {
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    pPmt->pcreateFile = mockCreateFileSuccess;
    uint32_t val = 0;
    pPmt->keyOffsetMap = dummyKeyOffsetMap;
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
 }

-TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32TypeWhenIoctlCallSucceedsThenreadValueReturned) {
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32TypeWhenIoctlCallSucceedsThenReadValueReturned) {
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    pPmt->pcreateFile = mockCreateFileSuccess;
    pPmt->pdeviceIoControl = mockDeviceIoControlSuccess;

@@ -108,7 +186,8 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32
        *static_cast<int *>(lpOutBuffer) = 4;
        return true;
    });
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    pPmt->pcreateFile = mockCreateFileSuccess;

    uint32_t val = 0;
@@ -122,7 +201,8 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64
        *static_cast<int *>(lpOutBuffer) = 4;
        return true;
    });
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    pPmt->pcreateFile = mockCreateFileSuccess;

    uint64_t val = 0;
@@ -130,8 +210,9 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64
    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val));
 }

-TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingreadValueWithUint64TypeAndIoctlCallSucceedsThenreadValueReturned) {
-    pPmt = std::make_unique<PublicPlatformMonitoringTech>(deviceInterface, pWddmSysmanImp->getSysmanProductHelper());
+TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64TypeAndIoctlCallSucceedsThenreadValueReturned) {
+    pPmt = std::make_unique<PublicPlatformMonitoringTech>(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    pPmt->deviceInterface = L0::Sysman::ult::deviceInterface;
    pPmt->pcreateFile = mockCreateFileSuccess;
    pPmt->pdeviceIoControl = mockDeviceIoControlSuccess;
    uint64_t val = 0;
@@ -141,7 +222,7 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingreadValueWithUint64
 }

 TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtInterfaceWhenCallingCreateThenCallReturnsNullPtr) {
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

@@ -150,135 +231,130 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtInterfaceWhenCallingGetSysmanPmtTh
    EXPECT_EQ(nullptr, pPmt);
 }

-TEST_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWithUnsupportedGuidWhenCallingGetSysmanPmtThenCallReturnsNullPtr) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
-        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
-            *static_cast<unsigned long *>(lpOutBuffer) = 40;
-        } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
-            PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
-            *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
-        }
-        return true;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
+TEST_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWithUnsupportedGuidWhenCallingCreateThenCallReturnsNullPtr) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+
    struct MockSysmanProductHelperPmt : L0::Sysman::SysmanProductHelperHw<IGFX_UNKNOWN> {
        MockSysmanProductHelperPmt() = default;
    };

    std::unique_ptr<SysmanProductHelper> pSysmanProductHelper = std::make_unique<MockSysmanProductHelperPmt>();
    std::swap(pWddmSysmanImp->pSysmanProductHelper, pSysmanProductHelper);
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCallSucceeds, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
-        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
-            *static_cast<unsigned long *>(lpOutBuffer) = 40;
-        } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
-            PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
-            *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
-        }
-        return true;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_NE(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenInValidPmtInterfaceNameWhenCallingCreateThenCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
-        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
-            *static_cast<unsigned long *>(lpOutBuffer) = 40;
-        } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
-            PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
-            *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
-        }
-        return true;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
        wcscpy(buffer, L"TEST_WRONG_INTERFACE");
        return CR_SUCCESS;
    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateWithNoGuidsFoundThenCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
            *static_cast<unsigned long *>(lpOutBuffer) = 40;
        }
        return true;
    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtrySizeIsZeroThenCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
            *static_cast<unsigned long *>(lpOutBuffer) = 0;
        }
        return true;
    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtryDiscoveryFailsThenCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
            *static_cast<unsigned long *>(lpOutBuffer) = 40;
@@ -287,53 +363,48 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTele
        }
        return true;
    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtryDiscoveryFailsThenCallFailsCoveringNewBranch, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCallSucceedsCoveringNewBranch, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
-        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
-            *static_cast<unsigned long *>(lpOutBuffer) = 40;
-        } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
-            PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
-            *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
-        }
-        return true;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    sysCallsInterfaceListCounter = 0;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        static int sysCallsInterfaceListCounter = 0;
        if (sysCallsInterfaceListCounter) {
            wcscpy(buffer, L"TEST_INTC_PMT");
            return CR_SUCCESS;
@@ -341,66 +412,105 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCal
        sysCallsInterfaceListCounter++;
        return CR_BUFFER_SMALL;
    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_NE(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenInValidPmtInterfaceWhenCallingCreateThenCallFails, IsBMG) {
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceInterfaceListFailsThenCallFails, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 4;
-        return CR_SUCCESS;
+        if (pDeviceID[0] != L'\0') {
+            *pulLen = 4;
+            return CR_SUCCESS;
+        }
+        return CR_FAILURE;
    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceInterfaceListSizeReturnZeroThenCallFails, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 0;
-        return CR_SUCCESS;
+        if (pDeviceID[0] != L'\0') {
+            *pulLen = 0;
+            return CR_SUCCESS;
+        }
+        return CR_FAILURE;
    });
    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
        return CR_SUCCESS;
    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndHeapAllocFailsThenCreateCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
            *static_cast<unsigned long *>(lpOutBuffer) = 40;
        }
        return true;
    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsHeapAlloc)> mockHeapAlloc(&NEO::SysCalls::sysCallsHeapAlloc, [](HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) -> LPVOID {
        return nullptr;
    });
-
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemetryIndexIsGreaterThanTotalPmtInterfacesThenCreateCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
            *static_cast<unsigned long *>(lpOutBuffer) = 40;
@@ -411,43 +521,336 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTele
        }
        return true;
    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

 HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndHeapFreeCallFailsThenCreateCallFails, IsBMG) {
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE {
-        return reinterpret_cast<HANDLE>(static_cast<uintptr_t>(0x7));
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL {
-        if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) {
-            *static_cast<unsigned long *>(lpOutBuffer) = 40;
-        } else if (static_cast<uint32_t>(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) {
-            PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}};
-            *static_cast<PmtSysman::PmtTelemetryDiscovery *>(lpOutBuffer) = temp;
-        }
-        return true;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET {
-        *pulLen = 40;
-        return CR_SUCCESS;
-    });
-    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
-        wcscpy(buffer, L"TEST_INTC_PMT");
-        return CR_SUCCESS;
-    });
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
    VariableBackup<decltype(NEO::SysCalls::sysCallsHeapFree)> mocksHeapFree(&NEO::SysCalls::sysCallsHeapFree, [](HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) -> BOOL {
        return false;
    });
-    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper());
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiGetClassDevsCallFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, [](GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) -> HDEVINFO {
+        return reinterpret_cast<HDEVINFO>(INVALID_HANDLE_VALUE);
+    });
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiDestroyDeviceInfoListFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, [](HDEVINFO deviceInfoSet) -> BOOL {
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiEnumDeviceInfoFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndGetDeviceRegistryPropertyFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    createCallCount = 2;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL {
+        if (createCallCount == 1) {
+            *requiredSize = 0x0;
+            return true;
+        } else {
+            if (requiredSize != nullptr) {
+                *requiredSize = 0x1;
+                return false;
+            }
+            return false;
+        }
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        if (createCallCount) {
+            createCallCount--;
+            return true;
+        }
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndGetDeviceRegistryPropertyFailsThenNullptrIsReturnedCoveringAdditionalBranch, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    createCallCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL {
+        if (property == SPDRP_BUSNUMBER) {
+            if (requiredSize != nullptr) {
+                *requiredSize = 0x1;
+                return false;
+            }
+            *propertyBuffer = 0u;
+            return true;
+        } else {
+            return true;
+        }
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        if (createCallCount) {
+            createCallCount--;
+            return true;
+        }
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndPciBDFMatchingFailsThenNullptrIsReturned, IsBMG) {
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL {
+        if (requiredSize != nullptr) {
+            *requiredSize = 0x1;
+            return false;
+        }
+        *propertyBuffer = 0u;
+        return true;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        if (createCallCount) {
+            createCallCount--;
+            return true;
+        }
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::vector<std::vector<uint32_t>> devicePciBdfCombinations = {{1, 1, 1}, {1, 1, 0}, {1, 0, 1}, {1, 0, 0}, {0, 1, 1}, {0, 1, 0}, {0, 0, 1}};
+    for (uint32_t i = 0; i < devicePciBdfCombinations.size(); i++) {
+        sysCallsCmGetChildCount = 1;
+        sysCallsCmGetSiblingCount = 1;
+        createCallCount = 1;
+
+        std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), devicePciBdfCombinations[i][0], devicePciBdfCombinations[i][1], devicePciBdfCombinations[i][2]);
+        EXPECT_EQ(nullptr, pPmt);
+    }
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdSizeFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, [](PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) -> CONFIGRET {
+        return CR_FAILURE;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
+        return CR_FAILURE;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdReturnEmptyIdThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, [](PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) -> CONFIGRET {
+        return CR_SUCCESS;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
+        return CR_SUCCESS;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiOpenDeviceInfoFailsThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, [](HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) -> BOOL {
+        return false;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
+    EXPECT_EQ(nullptr, pPmt);
+}
+
+HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdReturnsWrongIdThenNullptrIsReturned, IsBMG) {
+    sysCallsCmGetChildCount = 1;
+    sysCallsCmGetSiblingCount = 1;
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCreateFile)> psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsDeviceIoControl)> psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize)> psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceInterfaceList)> psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceIdSize)> psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetDeviceId)> psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET {
+        wcscpy(buffer, L"INVALID_TEST_ID");
+        return CR_SUCCESS;
+    });
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetChild)> psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsCmGetSibling)> psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty)> psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo)> psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo)> psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList)> psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess);
+    VariableBackup<decltype(NEO::SysCalls::sysCallsSetupDiGetClassDevs)> psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess);
+    std::unique_ptr<PlatformMonitoringTech> pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0);
    EXPECT_EQ(nullptr, pPmt);
 }

--- a/shared/source/os_interface/windows/sys_calls.cpp
+++ b/shared/source/os_interface/windows/sys_calls.cpp
@@ -177,6 +177,42 @@ CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDevic
    return CM_Get_Device_Interface_List(interfaceClassGuid, pDeviceID, buffer, bufferLen, ulFlags);
 }

+CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) {
+    return CM_Get_Device_ID_Size(pulLen, dnDevInst, ulFlags);
+}
+
+CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) {
+    return CM_Get_Device_ID(dnDevInst, buffer, bufferLen, ulFlags);
+}
+
+CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    return CM_Get_Child(pdnDevInst, dnDevInst, ulFlags);
+}
+
+CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    return CM_Get_Sibling(pdnDevInst, dnDevInst, ulFlags);
+}
+
+BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) {
+    return SetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, propertyRegDataType, propertyBuffer, propertyBufferSize, requiredSize);
+}
+
+BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) {
+    return SetupDiOpenDeviceInfo(deviceInfoSet, deviceInstanceId, hwndParent, openFlags, deviceInfoData);
+}
+
+BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) {
+    return SetupDiEnumDeviceInfo(deviceInfoSet, memberIndex, deviceInfoData);
+}
+
+BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet) {
+    return SetupDiDestroyDeviceInfoList(deviceInfoSet);
+}
+
+HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) {
+    return SetupDiGetClassDevs(classGuid, enumerator, hwndParent, flags);
+}
+
 LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) {
    return HeapAlloc(hHeap, dwFlags, dwBytes);
 }
--- a/shared/source/os_interface/windows/sys_calls.h
+++ b/shared/source/os_interface/windows/sys_calls.h
@@ -58,6 +58,15 @@ HANDLE createFile(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
 BOOL deviceIoControl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
 CONFIGRET cmGetDeviceInterfaceListSize(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags);
 CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags);
+CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags);
+CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags);
+CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
+CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
+BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize);
+BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData);
+BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData);
+BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet);
+HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags);
 LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes);
 BOOL heapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
 SIZE_T virtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
--- a/shared/source/os_interface/windows/windows_wrapper.h
+++ b/shared/source/os_interface/windows/windows_wrapper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2024 Intel Corporation
+ * Copyright (C) 2018-2025 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -18,6 +18,7 @@

 #include <Windows.h>

+#include <SetupAPI.h>
 #include <ShlObj.h>
 #include <cfgmgr32.h>
 #include <winternl.h>
--- a/shared/test/common/os_interface/windows/mock_sys_calls.h
+++ b/shared/test/common/os_interface/windows/mock_sys_calls.h
@@ -65,6 +65,15 @@ extern HANDLE (*sysCallsCreateFile)(LPCWSTR lpFileName, DWORD dwDesiredAccess, D
 extern BOOL (*sysCallsDeviceIoControl)(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
 extern CONFIGRET (*sysCallsCmGetDeviceInterfaceListSize)(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags);
 extern CONFIGRET (*sysCallsCmGetDeviceInterfaceList)(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags);
+extern CONFIGRET (*sysCallsCmGetDeviceIdSize)(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags);
+extern CONFIGRET (*sysCallsCmGetDeviceId)(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags);
+extern CONFIGRET (*sysCallsCmGetChild)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
+extern CONFIGRET (*sysCallsCmGetSibling)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags);
+extern BOOL (*sysCallsSetupDiGetDeviceRegistryProperty)(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize);
+extern BOOL (*sysCallsSetupDiOpenDeviceInfo)(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData);
+extern BOOL (*sysCallsSetupDiEnumDeviceInfo)(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData);
+extern BOOL (*sysCallsSetupDiDestroyDeviceInfoList)(HDEVINFO deviceInfoSet);
+extern HDEVINFO (*sysCallsSetupDiGetClassDevs)(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags);
 extern LPVOID (*sysCallsHeapAlloc)(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes);
 extern BOOL (*sysCallsHeapFree)(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);
 extern BOOL (*sysCallsDuplicateHandle)(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions);
--- a/shared/test/common/os_interface/windows/sys_calls.cpp
+++ b/shared/test/common/os_interface/windows/sys_calls.cpp
@@ -114,6 +114,33 @@ CONFIGRET(*sysCallsCmGetDeviceInterfaceListSize)
 CONFIGRET(*sysCallsCmGetDeviceInterfaceList)
 (LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) = nullptr;

+CONFIGRET(*sysCallsCmGetDeviceIdSize)
+(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) = nullptr;
+
+CONFIGRET(*sysCallsCmGetDeviceId)
+(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) = nullptr;
+
+CONFIGRET(*sysCallsCmGetChild)
+(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) = nullptr;
+
+CONFIGRET(*sysCallsCmGetSibling)
+(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) = nullptr;
+
+BOOL(*sysCallsSetupDiGetDeviceRegistryProperty)
+(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) = nullptr;
+
+BOOL(*sysCallsSetupDiOpenDeviceInfo)
+(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) = nullptr;
+
+BOOL(*sysCallsSetupDiEnumDeviceInfo)
+(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) = nullptr;
+
+BOOL(*sysCallsSetupDiDestroyDeviceInfoList)
+(HDEVINFO deviceInfoSet) = nullptr;
+
+HDEVINFO(*sysCallsSetupDiGetClassDevs)
+(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) = nullptr;
+
 LPVOID(*sysCallsHeapAlloc)
 (HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) = nullptr;

@@ -337,6 +364,69 @@ CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDevic
    return -1;
 }

+CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) {
+    if (sysCallsCmGetDeviceIdSize != nullptr) {
+        return sysCallsCmGetDeviceIdSize(pulLen, dnDevInst, ulFlags);
+    }
+    return -1;
+}
+
+CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) {
+    if (sysCallsCmGetDeviceId != nullptr) {
+        return sysCallsCmGetDeviceId(dnDevInst, buffer, bufferLen, ulFlags);
+    }
+    return -1;
+}
+
+CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    if (sysCallsCmGetChild != nullptr) {
+        return sysCallsCmGetChild(pdnDevInst, dnDevInst, ulFlags);
+    }
+    return -1;
+}
+
+CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) {
+    if (sysCallsCmGetSibling != nullptr) {
+        return sysCallsCmGetSibling(pdnDevInst, dnDevInst, ulFlags);
+    }
+    return -1;
+}
+
+BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) {
+    if (sysCallsSetupDiGetDeviceRegistryProperty != nullptr) {
+        return sysCallsSetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, propertyRegDataType, propertyBuffer, propertyBufferSize, requiredSize);
+    }
+    return false;
+}
+
+BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) {
+    if (sysCallsSetupDiOpenDeviceInfo != nullptr) {
+        return sysCallsSetupDiOpenDeviceInfo(deviceInfoSet, deviceInstanceId, hwndParent, openFlags, deviceInfoData);
+    }
+    return false;
+}
+
+BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) {
+    if (sysCallsSetupDiEnumDeviceInfo != nullptr) {
+        return sysCallsSetupDiEnumDeviceInfo(deviceInfoSet, memberIndex, deviceInfoData);
+    }
+    return false;
+}
+
+BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet) {
+    if (sysCallsSetupDiDestroyDeviceInfoList != nullptr) {
+        return sysCallsSetupDiDestroyDeviceInfoList(deviceInfoSet);
+    }
+    return false;
+}
+
+HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) {
+    if (sysCallsSetupDiGetClassDevs != nullptr) {
+        return sysCallsSetupDiGetClassDevs(classGuid, enumerator, hwndParent, flags);
+    }
+    return nullptr;
+}
+
 LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) {
    if (sysCallsHeapAlloc != nullptr) {
        return sysCallsHeapAlloc(hHeap, dwFlags, dwBytes);