refactor: Move Sysman APIs to level_zero/sysman/source/api

Signed-off-by: Jitendra Sharma <jitendra.sharma@intel.com>

level_zero/sysman/source/api/fan/CMakeLists.txt

@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${L0_STATIC_LIB_NAME}
+               PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_fan.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_fan.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_fan_imp.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_fan_imp.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_fan.h
+)
+
+add_subdirectories()

level_zero/sysman/source/api/fan/linux/CMakeLists.txt

@@ -0,0 +1,15 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_fan_imp.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_fan_imp.h
+  )
+endif()
+

level_zero/sysman/source/api/fan/linux/sysman_os_fan_imp.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/fan/linux/sysman_os_fan_imp.h"
+
+#include "level_zero/sysman/source/linux/pmt/sysman_pmt.h"
+#include "level_zero/sysman/source/linux/zes_os_sysman_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t LinuxFanImp::getProperties(zes_fan_properties_t *pProperties) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+ze_result_t LinuxFanImp::getConfig(zes_fan_config_t *pConfig) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxFanImp::setDefaultMode() {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxFanImp::setFixedSpeedMode(const zes_fan_speed_t *pSpeed) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxFanImp::setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool LinuxFanImp::isFanModuleSupported() {
+    return false;
+}
+
+LinuxFanImp::LinuxFanImp(OsSysman *pOsSysman) {
+}
+
+std::unique_ptr<OsFan> OsFan::create(OsSysman *pOsSysman) {
+    std::unique_ptr<LinuxFanImp> pLinuxFanImp = std::make_unique<LinuxFanImp>(pOsSysman);
+    return pLinuxFanImp;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/linux/sysman_os_fan_imp.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/api/fan/sysman_os_fan.h"
+
+namespace L0 {
+namespace Sysman {
+
+class SysfsAccess;
+
+class LinuxFanImp : public OsFan, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t getProperties(zes_fan_properties_t *pProperties) override;
+    ze_result_t getConfig(zes_fan_config_t *pConfig) override;
+    ze_result_t setDefaultMode() override;
+    ze_result_t setFixedSpeedMode(const zes_fan_speed_t *pSpeed) override;
+    ze_result_t setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) override;
+    ze_result_t getState(zes_fan_speed_units_t units, int32_t *pSpeed) override;
+    bool isFanModuleSupported() override;
+    LinuxFanImp(OsSysman *pOsSysman);
+    LinuxFanImp() = default;
+    ~LinuxFanImp() override = default;
+};
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/sysman_fan.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/fan/sysman_fan.h"
+
+#include "shared/source/helpers/basic_math.h"
+
+#include "level_zero/sysman/source/api/fan/sysman_fan_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+FanHandleContext::~FanHandleContext() = default;
+
+void FanHandleContext::init() {
+    std::unique_ptr<Fan> pFan = std::make_unique<FanImp>(pOsSysman);
+    if (pFan->initSuccess == true) {
+        handleList.push_back(std::move(pFan));
+    }
+}
+
+ze_result_t FanHandleContext::fanGet(uint32_t *pCount, zes_fan_handle_t *phFan) {
+    std::call_once(initFanOnce, [this]() {
+        this->init();
+    });
+    uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
+    if (0 == *pCount) {
+        *pCount = handleListSize;
+        return ZE_RESULT_SUCCESS;
+    }
+    *pCount = std::min(*pCount, handleListSize);
+    if (nullptr != phFan) {
+        for (uint32_t i = 0; i < *pCount; i++) {
+            phFan[i] = handleList[i]->toHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/sysman_fan.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/api/sysman/zes_handles_struct.h"
+#include <level_zero/zes_api.h>
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace L0 {
+namespace Sysman {
+struct OsSysman;
+class Fan : _zes_fan_handle_t {
+  public:
+    virtual ze_result_t fanGetProperties(zes_fan_properties_t *pProperties) = 0;
+    virtual ze_result_t fanGetConfig(zes_fan_config_t *pConfig) = 0;
+    virtual ze_result_t fanSetDefaultMode() = 0;
+    virtual ze_result_t fanSetFixedSpeedMode(const zes_fan_speed_t *pSpeed) = 0;
+    virtual ze_result_t fanSetSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) = 0;
+    virtual ze_result_t fanGetState(zes_fan_speed_units_t units, int32_t *pSpeed) = 0;
+
+    static Fan *fromHandle(zes_fan_handle_t handle) {
+        return static_cast<Fan *>(handle);
+    }
+    inline zes_fan_handle_t toHandle() { return this; }
+    bool initSuccess = false;
+};
+struct FanHandleContext {
+    FanHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
+    ~FanHandleContext();
+
+    void init();
+
+    ze_result_t fanGet(uint32_t *pCount, zes_fan_handle_t *phFan);
+
+    OsSysman *pOsSysman = nullptr;
+    std::vector<std::unique_ptr<Fan>> handleList = {};
+
+  private:
+    std::once_flag initFanOnce;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/sysman_fan_imp.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/fan/sysman_fan_imp.h"
+
+#include "shared/source/helpers/debug_helpers.h"
+
+namespace L0 {
+namespace Sysman {
+
+FanImp::FanImp(OsSysman *pOsSysman) {
+    pOsFan = OsFan::create(pOsSysman);
+    UNRECOVERABLE_IF(nullptr == pOsFan);
+
+    init();
+}
+
+ze_result_t FanImp::fanGetProperties(zes_fan_properties_t *pProperties) {
+    return pOsFan->getProperties(pProperties);
+}
+
+ze_result_t FanImp::fanGetConfig(zes_fan_config_t *pConfig) {
+    return pOsFan->getConfig(pConfig);
+}
+
+ze_result_t FanImp::fanSetDefaultMode() {
+    return pOsFan->setDefaultMode();
+}
+
+ze_result_t FanImp::fanSetFixedSpeedMode(const zes_fan_speed_t *pSpeed) {
+    return pOsFan->setFixedSpeedMode(pSpeed);
+}
+
+ze_result_t FanImp::fanSetSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) {
+    return pOsFan->setSpeedTableMode(pSpeedTable);
+}
+
+ze_result_t FanImp::fanGetState(zes_fan_speed_units_t units, int32_t *pSpeed) {
+    return pOsFan->getState(units, pSpeed);
+}
+
+void FanImp::init() {
+    if (pOsFan->isFanModuleSupported()) {
+        this->initSuccess = true;
+    }
+}
+
+FanImp::~FanImp() = default;
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/sysman_fan_imp.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/api/fan/sysman_fan.h"
+#include "level_zero/sysman/source/api/fan/sysman_os_fan.h"
+
+namespace L0 {
+namespace Sysman {
+class FanImp : public Fan, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t fanGetProperties(zes_fan_properties_t *pProperties) override;
+    ze_result_t fanGetConfig(zes_fan_config_t *pConfig) override;
+    ze_result_t fanSetDefaultMode() override;
+    ze_result_t fanSetFixedSpeedMode(const zes_fan_speed_t *pSpeed) override;
+    ze_result_t fanSetSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) override;
+    ze_result_t fanGetState(zes_fan_speed_units_t units, int32_t *pSpeed) override;
+    FanImp() = default;
+    FanImp(OsSysman *pOsSysman);
+    ~FanImp() override;
+
+    std::unique_ptr<OsFan> pOsFan;
+    void init();
+};
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/sysman_os_fan.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include <level_zero/zes_api.h>
+
+#include <memory>
+
+namespace L0 {
+namespace Sysman {
+
+struct OsSysman;
+class OsFan {
+  public:
+    virtual ze_result_t getProperties(zes_fan_properties_t *pProperties) = 0;
+    virtual ze_result_t getConfig(zes_fan_config_t *pConfig) = 0;
+    virtual ze_result_t setDefaultMode() = 0;
+    virtual ze_result_t setFixedSpeedMode(const zes_fan_speed_t *pSpeed) = 0;
+    virtual ze_result_t setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) = 0;
+    virtual ze_result_t getState(zes_fan_speed_units_t units, int32_t *pSpeed) = 0;
+    virtual bool isFanModuleSupported() = 0;
+    static std::unique_ptr<OsFan> create(OsSysman *pOsSysman);
+    virtual ~OsFan() = default;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(WIN32)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_fan_imp.h
+                 ${CMAKE_CURRENT_SOURCE_DIR}/sysman_os_fan_imp.cpp
+  )
+endif()

level_zero/sysman/source/api/fan/windows/sysman_os_fan_imp.cpp

@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/api/fan/windows/sysman_os_fan_imp.h"
+
+#include "level_zero/sysman/source/windows/sysman_kmd_sys_manager.h"
+
+namespace L0 {
+namespace Sysman {
+
+struct FanPoint {
+    union {
+        struct {
+            int32_t temperatureDegreesCelsius : 16;
+            int32_t fanSpeedPercent : 16;
+        };
+        int32_t data;
+    };
+};
+
+ze_result_t WddmFanImp::getProperties(zes_fan_properties_t *pProperties) {
+    pProperties->onSubdevice = false;
+    pProperties->subdeviceId = 0;
+
+    std::vector<KmdSysman::RequestProperty> vRequests = {};
+    std::vector<KmdSysman::ResponseProperty> vResponses = {};
+    KmdSysman::RequestProperty request = {};
+
+    request.commandId = KmdSysman::Command::Set;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentNumOfControlPoints;
+    request.dataSize = sizeof(uint32_t);
+
+    uint32_t FanPoints = 2;
+    memcpy_s(request.dataBuffer, sizeof(uint32_t), &FanPoints, sizeof(uint32_t));
+
+    vRequests.push_back(request);
+
+    request.dataSize = 0;
+    memset(request.dataBuffer, request.dataSize, sizeof(request.dataBuffer));
+    request.commandId = KmdSysman::Command::Get;
+    request.requestId = KmdSysman::Requests::Fans::MaxFanControlPointsSupported;
+
+    vRequests.push_back(request);
+
+    ze_result_t status = pKmdSysManager->requestMultiple(vRequests, vResponses);
+
+    if ((status != ZE_RESULT_SUCCESS) || (vResponses.size() != vRequests.size())) {
+        return status;
+    }
+
+    pProperties->canControl = (vResponses[0].returnCode == KmdSysman::Success);
+
+    if (vResponses[1].returnCode == KmdSysman::Success) {
+        memcpy_s(&FanPoints, sizeof(uint32_t), vResponses[1].dataBuffer, sizeof(uint32_t));
+        pProperties->maxPoints = maxPoints = static_cast<int32_t>(FanPoints);
+    }
+    pProperties->maxRPM = -1;
+    pProperties->supportedModes = zes_fan_speed_mode_t::ZES_FAN_SPEED_MODE_TABLE;
+    pProperties->supportedUnits = zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_PERCENT;
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t WddmFanImp::getConfig(zes_fan_config_t *pConfig) {
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentNumOfControlPoints;
+
+    ze_result_t status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    } else {
+        uint32_t value = 0;
+        memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+        if (value == 0) {
+            pConfig->mode = ZES_FAN_SPEED_MODE_DEFAULT;
+        } else {
+            pConfig->mode = ZES_FAN_SPEED_MODE_TABLE;
+            pConfig->speedTable.numPoints = value;
+
+            request.requestId = KmdSysman::Requests::Fans::CurrentFanPoint;
+
+            for (int32_t i = 0; i < pConfig->speedTable.numPoints; i++) {
+                if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
+
+                    FanPoint point = {};
+                    memcpy_s(&point.data, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+
+                    pConfig->speedTable.table[i].speed.speed = point.fanSpeedPercent;
+                    pConfig->speedTable.table[i].speed.units = ZES_FAN_SPEED_UNITS_PERCENT;
+                    pConfig->speedTable.table[i].temperature = point.temperatureDegreesCelsius;
+                }
+            }
+        }
+    }
+
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t WddmFanImp::setDefaultMode() {
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+
+    // Passing current number of control points as zero will reset pcode to default fan curve
+    uint32_t value = 0; // 0 to reset to default
+    request.commandId = KmdSysman::Command::Set;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentNumOfControlPoints;
+    request.dataSize = sizeof(uint32_t);
+    memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
+
+    return pKmdSysManager->requestSingle(request, response);
+}
+
+ze_result_t WddmFanImp::setFixedSpeedMode(const zes_fan_speed_t *pSpeed) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmFanImp::setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) {
+
+    KmdSysman::RequestProperty singleRequest;
+    KmdSysman::ResponseProperty singleResponse;
+    singleRequest.commandId = KmdSysman::Command::Get;
+    singleRequest.componentId = KmdSysman::Component::FanComponent;
+    singleRequest.requestId = KmdSysman::Requests::Fans::MaxFanControlPointsSupported;
+    uint32_t FanPoints = 2;
+
+    if (pKmdSysManager->requestSingle(singleRequest, singleResponse) == ZE_RESULT_SUCCESS) {
+        if (singleResponse.returnCode == KmdSysman::Success) {
+            memcpy_s(&FanPoints, sizeof(uint32_t), singleResponse.dataBuffer, sizeof(uint32_t));
+        }
+        maxPoints = static_cast<int32_t>(FanPoints);
+    }
+
+    if (pSpeedTable->numPoints == 0 || pSpeedTable->numPoints > maxPoints) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    for (int32_t i = 0; i < pSpeedTable->numPoints; i++) {
+        if (pSpeedTable->table[i].speed.units == zes_fan_speed_units_t::ZES_FAN_SPEED_UNITS_RPM) {
+            return ze_result_t::ZE_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+    }
+
+    std::vector<KmdSysman::RequestProperty> vRequests = {};
+    std::vector<KmdSysman::ResponseProperty> vResponses = {};
+    KmdSysman::RequestProperty request = {};
+
+    uint32_t value = pSpeedTable->numPoints;
+
+    request.commandId = KmdSysman::Command::Set;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentNumOfControlPoints;
+    request.dataSize = sizeof(uint32_t);
+    memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
+    vRequests.push_back(request);
+
+    request.requestId = KmdSysman::Requests::Fans::CurrentFanPoint;
+    for (int32_t i = 0; i < pSpeedTable->numPoints; i++) {
+        FanPoint point = {};
+        point.fanSpeedPercent = pSpeedTable->table[i].speed.speed;
+        point.temperatureDegreesCelsius = pSpeedTable->table[i].temperature;
+        value = point.data;
+        memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
+        vRequests.push_back(request);
+    }
+
+    return pKmdSysManager->requestMultiple(vRequests, vResponses);
+}
+
+ze_result_t WddmFanImp::getState(zes_fan_speed_units_t units, int32_t *pSpeed) {
+    if (units == ZES_FAN_SPEED_UNITS_PERCENT) {
+        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    KmdSysman::RequestProperty request;
+    KmdSysman::ResponseProperty response;
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentFanSpeed;
+
+    ze_result_t status = pKmdSysManager->requestSingle(request, response);
+
+    if (status != ZE_RESULT_SUCCESS) {
+        return status;
+    }
+
+    uint32_t value = 0;
+    memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
+
+    *pSpeed = static_cast<int32_t>(value);
+
+    return status;
+}
+
+bool WddmFanImp::isFanModuleSupported() {
+    KmdSysman::RequestProperty request = {};
+    KmdSysman::ResponseProperty response = {};
+
+    request.commandId = KmdSysman::Command::Get;
+    request.componentId = KmdSysman::Component::FanComponent;
+    request.requestId = KmdSysman::Requests::Fans::CurrentFanSpeed;
+
+    return (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS);
+}
+
+WddmFanImp::WddmFanImp(OsSysman *pOsSysman) {
+    WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
+    pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
+}
+
+std::unique_ptr<OsFan> OsFan::create(OsSysman *pOsSysman) {
+    std::unique_ptr<WddmFanImp> pWddmFanImp = std::make_unique<WddmFanImp>(pOsSysman);
+    return pWddmFanImp;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/api/fan/windows/sysman_os_fan_imp.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/api/fan/sysman_os_fan.h"
+#include "level_zero/sysman/source/windows/zes_os_sysman_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+class KmdSysManager;
+class WddmFanImp : public OsFan, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t getProperties(zes_fan_properties_t *pProperties) override;
+    ze_result_t getConfig(zes_fan_config_t *pConfig) override;
+    ze_result_t setDefaultMode() override;
+    ze_result_t setFixedSpeedMode(const zes_fan_speed_t *pSpeed) override;
+    ze_result_t setSpeedTableMode(const zes_fan_speed_table_t *pSpeedTable) override;
+    ze_result_t getState(zes_fan_speed_units_t units, int32_t *pSpeed) override;
+    bool isFanModuleSupported() override;
+
+    WddmFanImp(OsSysman *pOsSysman);
+    WddmFanImp() = default;
+    ~WddmFanImp() override = default;
+
+  protected:
+    KmdSysManager *pKmdSysManager = nullptr;
+
+  private:
+    uint64_t prevTS = 0;
+    uint32_t prevPulses = 0;
+    int32_t maxPoints = 0;
+};
+
+} // namespace Sysman
+} // namespace L0