Update sysman standby APIs to support latest spec.

Change-Id: I7a605c538432b2117ba968f155e4665078abc94f
Signed-off-by: Vilvaraj, T J Vivek <t.j.vivek.vilvaraj@intel.com>

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

@@ -5,6 +5,7 @@
  *
  */
 
+#pragma once
 #include "shared/source/helpers/non_copyable_or_moveable.h"
 #include "shared/source/os_interface/linux/drm_neo.h"
 #include "shared/source/os_interface/linux/os_interface.h"

level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp

@@ -11,24 +11,54 @@ namespace L0 {
 
 const std::string LinuxStandbyImp::standbyModeFile("power/rc6_enable");
 
+bool LinuxStandbyImp::isStandbySupported(void) {
+    if (ZE_RESULT_SUCCESS == pSysfsAccess->canRead(standbyModeFile)) {
+        return true;
+    } else {
+        return false;
+    }
+}
 ze_result_t LinuxStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
-    int currentMode;
+    int currentMode = -1;
     ze_result_t result = pSysfsAccess->read(standbyModeFile, currentMode);
     if (ZE_RESULT_SUCCESS != result) {
         return result;
     }
     if (standbyModeDefault == currentMode) {
         mode = ZET_STANDBY_PROMO_MODE_DEFAULT;
-        return ZE_RESULT_SUCCESS;
-    }
-    if (standbyModeNever == currentMode) {
+    } else if (standbyModeNever == currentMode) {
         mode = ZET_STANDBY_PROMO_MODE_NEVER;
-        return ZE_RESULT_SUCCESS;
+    } else {
+        result = ZE_RESULT_ERROR_UNKNOWN;
     }
-    return ZE_RESULT_ERROR_UNKNOWN;
+    return result;
+}
+ze_result_t LinuxStandbyImp::setMode(zet_standby_promo_mode_t mode) {
+    // standbyModeFile is not writable.
+    // Mode cannot be set from L0.
+    // To set the mode, user must reload
+    // the i915 module and set module parameter
+    // enable_rc6 appropriately.
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t LinuxStandbyImp::setMode(zet_standby_promo_mode_t mode) {
+ze_result_t LinuxStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
+    int currentMode = -1;
+    ze_result_t result = pSysfsAccess->read(standbyModeFile, currentMode);
+    if (ZE_RESULT_SUCCESS != result) {
+        return result;
+    }
+    if (standbyModeDefault == currentMode) {
+        mode = ZES_STANDBY_PROMO_MODE_DEFAULT;
+    } else if (standbyModeNever == currentMode) {
+        mode = ZES_STANDBY_PROMO_MODE_NEVER;
+    } else {
+        result = ZE_RESULT_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+ze_result_t LinuxStandbyImp::setMode(zes_standby_promo_mode_t mode) {
     // standbyModeFile is not writable.
     // Mode cannot be set from L0.
     // To set the mode, user must reload

level_zero/tools/source/sysman/standby/linux/os_standby_imp.h

@@ -18,6 +18,12 @@ class LinuxStandbyImp : public OsStandby, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
     ze_result_t setMode(zet_standby_promo_mode_t mode) override;
+
+    ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
+    ze_result_t setMode(zes_standby_promo_mode_t mode) override;
+
+    bool isStandbySupported(void) override;
+
     LinuxStandbyImp() = default;
     LinuxStandbyImp(OsSysman *pOsSysman);
     ~LinuxStandbyImp() override = default;

level_zero/tools/source/sysman/standby/os_standby.h

@@ -10,6 +10,8 @@
 #include "level_zero/tools/source/sysman/os_sysman.h"
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 namespace L0 {
 
 class OsStandby {
@@ -17,6 +19,11 @@ class OsStandby {
     virtual ze_result_t getMode(zet_standby_promo_mode_t &mode) = 0;
     virtual ze_result_t setMode(zet_standby_promo_mode_t mode) = 0;
 
+    virtual ze_result_t getMode(zes_standby_promo_mode_t &mode) = 0;
+    virtual ze_result_t setMode(zes_standby_promo_mode_t mode) = 0;
+
+    virtual bool isStandbySupported(void) = 0;
+
     static OsStandby *create(OsSysman *pOsSysman);
     virtual ~OsStandby() {}
 };

level_zero/tools/source/sysman/standby/standby.cpp

@@ -19,10 +19,13 @@ StandbyHandleContext::~StandbyHandleContext() {
     }
 }
 
-ze_result_t StandbyHandleContext::init() {
+void StandbyHandleContext::init() {
     Standby *pStandby = new StandbyImp(pOsSysman);
-    handleList.push_back(pStandby);
-    return ZE_RESULT_SUCCESS;
+    if (pStandby->isStandbyEnabled == true) {
+        handleList.push_back(pStandby);
+    } else {
+        delete pStandby;
+    }
 }
 
 ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) {
@@ -39,4 +42,17 @@ ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zet_sysman_standb
     return ZE_RESULT_SUCCESS;
 }
 
+ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
+    uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
+    uint32_t numToCopy = std::min(*pCount, handleListSize);
+    if (0 == *pCount || *pCount > handleListSize) {
+        *pCount = handleListSize;
+    }
+    if (nullptr != phStandby) {
+        for (uint32_t i = 0; i < numToCopy; i++) {
+            phStandby[i] = handleList[i]->toStandbyHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
 } // namespace L0

level_zero/tools/source/sysman/standby/standby.h

@@ -8,34 +8,53 @@
 #pragma once
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 #include <vector>
 
-struct _zet_sysman_standby_handle_t {};
+struct _zet_sysman_standby_handle_t {
+    virtual ~_zet_sysman_standby_handle_t() = default;
+};
+struct _zes_standby_handle_t {
+    virtual ~_zes_standby_handle_t() = default;
+};
 
 namespace L0 {
 
 struct OsSysman;
 
-class Standby : _zet_sysman_standby_handle_t {
+class Standby : _zet_sysman_standby_handle_t, _zes_standby_handle_t {
   public:
     virtual ~Standby() {}
     virtual ze_result_t standbyGetProperties(zet_standby_properties_t *pProperties) = 0;
     virtual ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) = 0;
     virtual ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) = 0;
 
+    virtual ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) = 0;
+    virtual ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) = 0;
+    virtual ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) = 0;
+
+    inline zet_sysman_standby_handle_t toHandle() { return this; }
+    inline zes_standby_handle_t toStandbyHandle() { return this; }
+
     static Standby *fromHandle(zet_sysman_standby_handle_t handle) {
         return static_cast<Standby *>(handle);
     }
-    inline zet_sysman_standby_handle_t toHandle() { return this; }
+
+    static Standby *fromHandle(zes_standby_handle_t handle) {
+        return static_cast<Standby *>(handle);
+    }
+    bool isStandbyEnabled = false;
 };
 
 struct StandbyHandleContext {
     StandbyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
     ~StandbyHandleContext();
 
-    ze_result_t init();
+    void init();
 
     ze_result_t standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby);
+    ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby);
 
     OsSysman *pOsSysman;
     std::vector<Standby *> handleList = {};

level_zero/tools/source/sysman/standby/standby_imp.cpp

@@ -26,16 +26,33 @@ ze_result_t StandbyImp::standbySetMode(const zet_standby_promo_mode_t mode) {
     return pOsStandby->setMode(mode);
 }
 
+ze_result_t StandbyImp::standbyGetProperties(zes_standby_properties_t *pProperties) {
+    *pProperties = zesStandbyProperties;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t StandbyImp::standbyGetMode(zes_standby_promo_mode_t *pMode) {
+    return pOsStandby->getMode(*pMode);
+}
+
+ze_result_t StandbyImp::standbySetMode(const zes_standby_promo_mode_t mode) {
+    return pOsStandby->setMode(mode);
+}
+
 void StandbyImp::init() {
     standbyProperties.type = ZET_STANDBY_TYPE_GLOBAL; // Currently the only defined type
     standbyProperties.onSubdevice = false;
     standbyProperties.subdeviceId = 0;
+    zesStandbyProperties.type = ZES_STANDBY_TYPE_GLOBAL;
+    zesStandbyProperties.onSubdevice = false;
+    zesStandbyProperties.subdeviceId = 0;
+    zesStandbyProperties.pNext = nullptr;
+    this->isStandbyEnabled = pOsStandby->isStandbySupported();
 }
 
 StandbyImp::StandbyImp(OsSysman *pOsSysman) {
     pOsStandby = OsStandby::create(pOsSysman);
     UNRECOVERABLE_IF(nullptr == pOsStandby);
-
     init();
 }
 

level_zero/tools/source/sysman/standby/standby_imp.h

@@ -12,6 +12,7 @@
 
 #include "os_standby.h"
 #include "standby.h"
+#include "third_party/level_zero/zes_api_ext.h"
 
 namespace L0 {
 
@@ -21,6 +22,10 @@ class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
     ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) override;
     ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) override;
 
+    ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) override;
+    ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) override;
+    ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) override;
+
     StandbyImp() = default;
     StandbyImp(OsSysman *pOsSysman);
     ~StandbyImp() override;
@@ -30,6 +35,7 @@ class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
 
   private:
     zet_standby_properties_t standbyProperties = {};
+    zes_standby_properties_t zesStandbyProperties = {};
 };
 
 } // namespace L0

level_zero/tools/source/sysman/standby/windows/os_standby_imp.cpp

@@ -13,6 +13,9 @@ class WddmStandbyImp : public OsStandby {
   public:
     ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
     ze_result_t setMode(zet_standby_promo_mode_t mode) override;
+    ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
+    ze_result_t setMode(zes_standby_promo_mode_t mode) override;
+    bool isStandbySupported(void) override;
 };
 
 ze_result_t WddmStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
@@ -23,6 +26,18 @@ ze_result_t WddmStandbyImp::setMode(zet_standby_promo_mode_t mode) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
+ze_result_t WddmStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmStandbyImp::setMode(zes_standby_promo_mode_t mode) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool WddmStandbyImp::isStandbySupported(void) {
+    return false;
+}
+
 OsStandby *OsStandby::create(OsSysman *pOsSysman) {
     WddmStandbyImp *pWddmStandbyImp = new WddmStandbyImp();
     return static_cast<OsStandby *>(pWddmStandbyImp);

level_zero/tools/source/sysman/sysman.h

@@ -85,6 +85,7 @@ struct SysmanDevice : _ze_device_handle_t {
     virtual ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) = 0;
     virtual ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) = 0;
     virtual ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) = 0;
+    virtual ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) = 0;
     virtual ~SysmanDevice() = default;
 };
 

level_zero/tools/source/sysman/sysman_imp.cpp

@@ -26,9 +26,11 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
     pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
     pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
     pTempHandleContext = new TemperatureHandleContext(pOsSysman);
+    pStandbyHandleContext = new StandbyHandleContext(pOsSysman);
 }
 
 SysmanDeviceImp::~SysmanDeviceImp() {
+    freeResource(pStandbyHandleContext);
     freeResource(pTempHandleContext);
     freeResource(pFabricPortHandleContext);
     freeResource(pFrequencyHandleContext);
@@ -50,6 +52,9 @@ void SysmanDeviceImp::init() {
     if (pTempHandleContext) {
         pTempHandleContext->init();
     }
+    if (pStandbyHandleContext) {
+        pStandbyHandleContext->init();
+    }
 }
 
 SysmanImp::SysmanImp(ze_device_handle_t hDevice) {
@@ -226,6 +231,10 @@ ze_result_t SysmanImp::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t
     return pStandbyHandleContext->standbyGet(pCount, phStandby);
 }
 
+ze_result_t SysmanDeviceImp::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
+    return pStandbyHandleContext->standbyGet(pCount, phStandby);
+}
+
 ze_result_t SysmanImp::firmwareGet(uint32_t *pCount, zet_sysman_firmware_handle_t *phFirmware) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }

level_zero/tools/source/sysman/sysman_imp.h

@@ -95,11 +95,13 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     FrequencyHandleContext *pFrequencyHandleContext = nullptr;
     FabricPortHandleContext *pFabricPortHandleContext = nullptr;
     TemperatureHandleContext *pTempHandleContext = nullptr;
+    StandbyHandleContext *pStandbyHandleContext = nullptr;
 
     ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) override;
     ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override;
     ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override;
     ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) override;
+    ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) override;
 
   private:
     template <typename T>