Revert "Revert "libhwc2.1: support setIdleTimerEnabled""

This reverts commit 13c602ef2fa6ec36e9ec02633ec7727fd4427d3c.

Reason for revert: avc denied is addressed in another patch

Bug: 219857957
Bug: 198808492
Test: composer access panel_idle withou avc denied
Change-Id: If1753cde988d8e2c755168bbc174da9faf138b91

16 files changed, 188 insertions, 21 deletions

diff --git a/hwc3/ComposerClient.cpp b/hwc3/ComposerClient.cpp
index 848d1f7..49d0e80 100644
--- a/hwc3/ComposerClient.cpp
+++ b/hwc3/ComposerClient.cpp
@@ -162,6 +162,16 @@ ndk::ScopedAStatus ComposerClient::getDisplayCapabilities(int64_t display,
         return TO_BINDER_STATUS(err);
     }
 
+    bool support = false;
+    err = mHal->getDisplayIdleTimerSupport(display, support);
+    if (err != ::android::OK) {
+        LOG(ERROR) << "failed to getDisplayIdleTimerSupport: " << err;
+    }
+
+    if (support) {
+        caps->push_back(DisplayCapability::DISPLAY_IDLE_TIMER);
+    }
+
     return TO_BINDER_STATUS(err);
 }
 
diff --git a/hwc3/impl/HalImpl.cpp b/hwc3/impl/HalImpl.cpp
index 1a56cfa..17fc4b2 100644
--- a/hwc3/impl/HalImpl.cpp
+++ b/hwc3/impl/HalImpl.cpp
@@ -941,12 +941,11 @@ int32_t HalImpl::setVsyncEnabled(int64_t display, bool enabled) {
     return halDisplay->setVsyncEnabled(hwcEnable);
 }
 
-int32_t HalImpl::setIdleTimerEnabled(int64_t display, int32_t __unused timeout) {
+int32_t HalImpl::setIdleTimerEnabled(int64_t display, int32_t timeout) {
     ExynosDisplay* halDisplay;
     RET_IF_ERR(getHalDisplay(display, halDisplay));
 
-    // TODO(b/198808492): implement setIdleTimerEnabled
-    return HWC2_ERROR_UNSUPPORTED;
+    return halDisplay->setDisplayIdleTimer(timeout);
 }
 
 int32_t HalImpl::validateDisplay(int64_t display, std::vector<int64_t>* outChangedLayers,
@@ -1016,4 +1015,11 @@ int32_t HalImpl::getRCDLayerSupport(int64_t display, bool& outSupport) {
     return halDisplay->getRCDLayerSupport(outSupport);
 }
 
+int32_t HalImpl::getDisplayIdleTimerSupport(int64_t display, bool& outSupport) {
+    ExynosDisplay* halDisplay;
+    RET_IF_ERR(getHalDisplay(display, halDisplay));
+
+    return halDisplay->getDisplayIdleTimerSupport(outSupport);
+}
+
 } // namespace aidl::android::hardware::graphics::composer3::impl
diff --git a/hwc3/impl/HalImpl.h b/hwc3/impl/HalImpl.h
index 2c6d540..d60d7d0 100644
--- a/hwc3/impl/HalImpl.h
+++ b/hwc3/impl/HalImpl.h
@@ -135,6 +135,7 @@ class HalImpl : public IComposerHal {
     int32_t setReadbackBuffer(int64_t display, buffer_handle_t buffer,
                               const ndk::ScopedFileDescriptor& releaseFence) override;
     int32_t setVsyncEnabled(int64_t display, bool enabled) override;
+    int32_t getDisplayIdleTimerSupport(int64_t display, bool& outSupport) override;
     int32_t setIdleTimerEnabled(int64_t display, int32_t timeout) override;
     int32_t getRCDLayerSupport(int64_t display, bool& outSupport) override;
     int32_t validateDisplay(int64_t display, std::vector<int64_t>* outChangedLayers,
diff --git a/hwc3/include/IComposerHal.h b/hwc3/include/IComposerHal.h
index 693c2b1..00bfdee 100644
--- a/hwc3/include/IComposerHal.h
+++ b/hwc3/include/IComposerHal.h
@@ -119,6 +119,8 @@ class IComposerHal {
     virtual int32_t getDisplayAttribute(int64_t display, int32_t config,
                                       DisplayAttribute attribute, int32_t* outValue) = 0;
     virtual int32_t getDisplayBrightnessSupport(int64_t display, bool& outSupport) = 0;
+    virtual int32_t getDisplayIdleTimerSupport(int64_t display, bool& outSupport) = 0;
+
     virtual int32_t getDisplayCapabilities(int64_t display,
                                            std::vector<DisplayCapability>* caps) = 0;
     virtual int32_t getDisplayConfigs(int64_t display, std::vector<int32_t>* configs) = 0;
diff --git a/libhwc2.1/libdevice/BrightnessController.cpp b/libhwc2.1/libdevice/BrightnessController.cpp
index f633e5a..7aa34f3 100644
--- a/libhwc2.1/libdevice/BrightnessController.cpp
+++ b/libhwc2.1/libdevice/BrightnessController.cpp
@@ -744,5 +744,5 @@ void BrightnessController::dump(String8& result) {
     result.appendFormat("\tdimming usage %d, hbm dimming %d, time us %d\n", mBrightnessDimmingUsage,
                         mHbmDimming, mHbmDimmingTimeUs);
     result.appendFormat("\twhite point nits %f\n", mDisplayWhitePointNits);
-    result.appendFormat("\n\n");
+    result.appendFormat("\n");
 }
diff --git a/libhwc2.1/libdevice/ExynosDevice.cpp b/libhwc2.1/libdevice/ExynosDevice.cpp
index 49296c6..bb9743a 100644
--- a/libhwc2.1/libdevice/ExynosDevice.cpp
+++ b/libhwc2.1/libdevice/ExynosDevice.cpp
@@ -1120,10 +1120,11 @@ int ExynosDevice::setRefreshRateThrottle(const int delayMs) {
 
     ExynosDisplay *display = getDisplay(getDisplayId(HWC_DISPLAY_PRIMARY, 0));
     if (display) {
-        return display->setRefreshRateThrottleNanos(
-                std::chrono::duration_cast<std::chrono::nanoseconds>(
-                        std::chrono::milliseconds(delayMs))
-                        .count());
+        return display
+                ->setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                                      std::chrono::milliseconds(delayMs))
+                                                      .count(),
+                                              DispIdleTimerRequester::PIXEL_DISP);
     }
     return BAD_VALUE;
 }
diff --git a/libhwc2.1/libdevice/ExynosDisplay.cpp b/libhwc2.1/libdevice/ExynosDisplay.cpp
index 73be285..d7502b1 100644
--- a/libhwc2.1/libdevice/ExynosDisplay.cpp
+++ b/libhwc2.1/libdevice/ExynosDisplay.cpp
@@ -5903,3 +5903,7 @@ int32_t ExynosDisplay::getRCDLayerSupport(bool &outSupport) {
     outSupport = mDpuData.rcdConfigs.size() > 0;
     return NO_ERROR;
 }
+
+int32_t ExynosDisplay::getDisplayIdleTimerSupport(bool &outSupport) {
+    return mDisplayInterface->getDisplayIdleTimerSupport(outSupport);
+}
diff --git a/libhwc2.1/libdevice/ExynosDisplay.h b/libhwc2.1/libdevice/ExynosDisplay.h
index b47450e..eae8c5f 100644
--- a/libhwc2.1/libdevice/ExynosDisplay.h
+++ b/libhwc2.1/libdevice/ExynosDisplay.h
@@ -145,6 +145,13 @@ enum class hwc_request_state_t {
     SET_CONFIG_STATE_REQUESTED,
 };
 
+enum class DispIdleTimerRequester : uint32_t {
+    SF = 0,
+    PIXEL_DISP,
+    TEST,
+    MAX,
+};
+
 #define NUM_SKIP_STATIC_LAYER  5
 struct ExynosFrameInfo
 {
@@ -1187,6 +1194,10 @@ class ExynosDisplay {
         virtual void setExpectedPresentTime(uint64_t __unused timestamp) {}
         virtual uint64_t getPendingExpectedPresentTime() { return 0; }
         virtual void applyExpectedPresentTime() {}
+        virtual int32_t getDisplayIdleTimerSupport(bool& outSupport);
+        virtual int32_t setDisplayIdleTimer(const int32_t __unused timeoutMs) {
+            return HWC2_ERROR_UNSUPPORTED;
+        }
 
         /* getDisplayPreAssignBit support mIndex up to 1.
            It supports only dual LCD and 2 external displays */
@@ -1215,7 +1226,8 @@ class ExynosDisplay {
         void requestLhbm(bool on);
 
         virtual int setMinIdleRefreshRate(const int __unused fps) { return NO_ERROR; }
-        virtual int setRefreshRateThrottleNanos(const int64_t __unused delayNanos) {
+        virtual int setRefreshRateThrottleNanos(const int64_t __unused delayNanos,
+                                                const DispIdleTimerRequester __unused requester) {
             return NO_ERROR;
         }
 
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
index ec1ea99..a08de5d 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.cpp
@@ -403,6 +403,18 @@ void ExynosDisplayDrmInterface::destroyLayer(ExynosLayer *layer) {
     mFBManager.cleanup(layer);
 }
 
+int32_t ExynosDisplayDrmInterface::getDisplayIdleTimerSupport(bool &outSupport) {
+    auto [ret, support] = mDrmConnector->panel_idle_support().value();
+    if (ret) {
+        ALOGI("no panel_idle_support drm property or invalid value (%d)", ret);
+        outSupport = false;
+    } else {
+        outSupport = (support > 0);
+    }
+
+    return NO_ERROR;
+}
+
 ExynosDisplayDrmInterface::ExynosDisplayDrmInterface(ExynosDisplay *exynosDisplay)
 {
     mType = INTERFACE_TYPE_DRM;
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
index 02303ed..71ecbd3 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterface.h
@@ -295,6 +295,9 @@ class ExynosDisplayDrmInterface :
         { return NO_ERROR;};
         virtual void destroyLayer(ExynosLayer *layer) override;
 
+        /* For HWC 3.0 APIs */
+        virtual int32_t getDisplayIdleTimerSupport(bool &outSupport);
+
         virtual int32_t waitVBlank();
         float getDesiredRefreshRate() { return mDesiredModeState.mode.v_refresh(); }
 
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h b/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
index 5028e39..ac773b5 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayInterface.h
@@ -71,6 +71,11 @@ class ExynosDisplayInterface {
         /* For HWC 2.4 APIs */
         virtual int32_t getVsyncAppliedTime(hwc2_config_t __unused config, int64_t* __unused actualChangeTime) {return NO_ERROR;}
         virtual void destroyLayer(ExynosLayer* __unused layer){};
+        /* For HWC 3.0 APIs */
+        virtual int32_t getDisplayIdleTimerSupport(bool& outSupport) {
+            outSupport = false;
+            return NO_ERROR;
+        }
 
         virtual int32_t waitVBlank() { return 0; };
     public:
diff --git a/libhwc2.1/libdrmresource/drm/drmconnector.cpp b/libhwc2.1/libdrmresource/drm/drmconnector.cpp
index 56e9070..3cbd24e 100644
--- a/libhwc2.1/libdrmresource/drm/drmconnector.cpp
+++ b/libhwc2.1/libdrmresource/drm/drmconnector.cpp
@@ -150,6 +150,11 @@ int DrmConnector::Init() {
       ALOGE("Could not get mipi_sync property\n");
   }
 
+  ret = drm_->GetConnectorProperty(*this, "panel_idle_support", &panel_idle_support_);
+  if (ret) {
+      ALOGE("Could not get panel_idle_support property\n");
+  }
+
   properties_.push_back(&dpms_property_);
   properties_.push_back(&crtc_id_property_);
   properties_.push_back(&edid_property_);
@@ -170,6 +175,7 @@ int DrmConnector::Init() {
   properties_.push_back(&dimming_on_);
   properties_.push_back(&lhbm_on_);
   properties_.push_back(&mipi_sync_);
+  properties_.push_back(&panel_idle_support_);
 
   return 0;
 }
@@ -381,6 +387,10 @@ int DrmConnector::ResetLpMode() {
     return 0;
 }
 
+const DrmProperty &DrmConnector::panel_idle_support() const {
+    return panel_idle_support_;
+}
+
 DrmEncoder *DrmConnector::encoder() const {
   return encoder_;
 }
diff --git a/libhwc2.1/libdrmresource/include/drmconnector.h b/libhwc2.1/libdrmresource/include/drmconnector.h
index 441c89f..cb6d1b2 100644
--- a/libhwc2.1/libdrmresource/include/drmconnector.h
+++ b/libhwc2.1/libdrmresource/include/drmconnector.h
@@ -80,6 +80,7 @@ class DrmConnector {
   const DrmProperty &dimming_on() const;
   const DrmProperty &lhbm_on() const;
   const DrmProperty &mipi_sync() const;
+  const DrmProperty &panel_idle_support() const;
 
   const std::vector<DrmProperty *> &properties() const {
       return properties_;
@@ -136,6 +137,7 @@ class DrmConnector {
   DrmProperty dimming_on_;
   DrmProperty lhbm_on_;
   DrmProperty mipi_sync_;
+  DrmProperty panel_idle_support_;
   std::vector<DrmProperty *> properties_;
 
   std::vector<DrmEncoder *> possible_encoders_;
diff --git a/libhwc2.1/libhwcService/ExynosHWCService.cpp b/libhwc2.1/libhwcService/ExynosHWCService.cpp
index 33d42ea..8c95e02 100644
--- a/libhwc2.1/libhwcService/ExynosHWCService.cpp
+++ b/libhwc2.1/libhwcService/ExynosHWCService.cpp
@@ -462,10 +462,11 @@ int32_t ExynosHWCService::setRefreshRateThrottle(uint32_t display_id, int32_t de
     auto display = mHWCCtx->device->getDisplay(display_id);
 
     if (display != nullptr) {
-        return display->setRefreshRateThrottleNanos(
-                std::chrono::duration_cast<std::chrono::nanoseconds>(
-                        std::chrono::milliseconds(delayMs))
-                        .count());
+        return display
+                ->setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                                      std::chrono::milliseconds(delayMs))
+                                                      .count(),
+                                              DispIdleTimerRequester::TEST);
     }
 
     return -EINVAL;
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
index ef122cd..54b9d29 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
@@ -74,7 +74,8 @@ ExynosPrimaryDisplay::ExynosPrimaryDisplay(uint32_t index, ExynosDevice *device)
         mMinIdleRefreshRate(0),
         mRefreshRateDelayNanos(0),
         mLastRefreshRateAppliedNanos(0),
-        mAppliedActiveConfig(0) {
+        mAppliedActiveConfig(0),
+        mDisplayIdleTimerEnabled(false) {
     // TODO : Hard coded here
     mNumMaxPriorityAllowed = 5;
 
@@ -300,6 +301,7 @@ int32_t ExynosPrimaryDisplay::setPowerMode(int32_t mode) {
 void ExynosPrimaryDisplay::firstPowerOn() {
     SetCurrentPanelGammaSource(DisplayType::DISPLAY_PRIMARY, PanelGammaSource::GAMMA_CALIBRATION);
     mFirstPowerOn = false;
+    getDisplayIdleTimerEnabled(mDisplayIdleTimerEnabled);
 }
 
 bool ExynosPrimaryDisplay::getHDRException(ExynosLayer* __unused layer)
@@ -460,6 +462,68 @@ void ExynosPrimaryDisplay::applyExpectedPresentTime() {
     mExpectedPresentTime.clear_dirty();
 }
 
+int32_t ExynosPrimaryDisplay::setDisplayIdleTimer(const int32_t timeoutMs) {
+    bool support = false;
+    if (getDisplayIdleTimerSupport(support) || support == false) {
+        return HWC2_ERROR_UNSUPPORTED;
+    }
+
+    if (timeoutMs < 0) {
+        return HWC2_ERROR_BAD_PARAMETER;
+    }
+
+    if (timeoutMs > 0) {
+        setRefreshRateThrottleNanos(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                            std::chrono::milliseconds(timeoutMs))
+                                            .count(),
+                                    DispIdleTimerRequester::SF);
+    }
+
+    bool enabled = (timeoutMs > 0);
+    if (enabled != mDisplayIdleTimerEnabled) {
+        if (setDisplayIdleTimerEnabled(enabled) == NO_ERROR) {
+            mDisplayIdleTimerEnabled = enabled;
+        }
+    }
+
+    return HWC2_ERROR_NONE;
+}
+
+int32_t ExynosPrimaryDisplay::getDisplayIdleTimerEnabled(bool &enabled) {
+    bool support = false;
+    if (getDisplayIdleTimerSupport(support) || support == false) {
+        return HWC2_ERROR_UNSUPPORTED;
+    }
+
+    const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "panel_idle";
+    std::ifstream ifs(path);
+    if (!ifs.is_open()) {
+        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
+        return errno;
+    } else {
+        std::string panel_idle;
+        std::getline(ifs, panel_idle);
+        ifs.close();
+        enabled = (panel_idle == "1");
+        ALOGI("%s() get panel_idle(%d) from the sysfs node", __func__, enabled);
+    }
+    return NO_ERROR;
+}
+
+int32_t ExynosPrimaryDisplay::setDisplayIdleTimerEnabled(const bool enabled) {
+    const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "panel_idle";
+    std::ofstream ofs(path);
+    if (!ofs.is_open()) {
+        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
+        return errno;
+    } else {
+        ofs << enabled;
+        ofs.close();
+        ALOGI("%s() writes panel_idle(%d) to the sysfs node", __func__, enabled);
+    }
+    return NO_ERROR;
+}
+
 int ExynosPrimaryDisplay::setMinIdleRefreshRate(const int fps) {
     mMinIdleRefreshRate = fps;
 
@@ -477,8 +541,30 @@ int ExynosPrimaryDisplay::setMinIdleRefreshRate(const int fps) {
     return NO_ERROR;
 }
 
-int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos) {
-    mRefreshRateDelayNanos = delayNanos;
+int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos,
+                                                      const DispIdleTimerRequester requester) {
+    ALOGI("%s() requester(%u) set delay to %" PRId64 "ns", __func__, toUnderlying(requester),
+          delayNanos);
+    if (delayNanos < 0) {
+        ALOGW("%s() set invalid delay(%" PRId64 ")", __func__, delayNanos);
+        return BAD_VALUE;
+    }
+
+    std::lock_guard<std::mutex> lock(mIdleRefreshRateThrottleMutex);
+
+    int64_t maxDelayNanos = 0;
+    mDisplayIdleTimerNanos[toUnderlying(requester)] = delayNanos;
+    for (uint32_t i = 0; i < toUnderlying(DispIdleTimerRequester::MAX); i++) {
+        if (mDisplayIdleTimerNanos[i] > maxDelayNanos) {
+            maxDelayNanos = mDisplayIdleTimerNanos[i];
+        }
+    }
+
+    if (mRefreshRateDelayNanos == maxDelayNanos) {
+        return NO_ERROR;
+    }
+
+    mRefreshRateDelayNanos = maxDelayNanos;
 
     const int32_t refreshRateDelayMs = std::chrono::duration_cast<std::chrono::milliseconds>(
                                                std::chrono::nanoseconds(mRefreshRateDelayNanos))
@@ -486,13 +572,13 @@ int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos)
     const std::string path = getPanelSysfsPath(DisplayType::DISPLAY_PRIMARY) + "idle_delay_ms";
     std::ofstream ofs(path);
     if (!ofs.is_open()) {
-        ALOGW("Unable to open node '%s', error = %s", path.c_str(), strerror(errno));
+        ALOGW("%s() unable to open node '%s', error = %s", __func__, path.c_str(), strerror(errno));
         return errno;
     } else {
         ofs << refreshRateDelayMs;
+        ALOGI("%s() writes idle_delay_ms(%d) to the sysfs node (0x%x)", __func__,
+              refreshRateDelayMs, ofs.rdstate());
         ofs.close();
-        ALOGI("ExynosPrimaryDisplay::%s() writes idle_delay_ms(%d) to the sysfs node", __func__,
-              refreshRateDelayMs);
     }
 
     return NO_ERROR;
@@ -501,7 +587,11 @@ int ExynosPrimaryDisplay::setRefreshRateThrottleNanos(const int64_t delayNanos)
 void ExynosPrimaryDisplay::dump(String8 &result) {
     ExynosDisplay::dump(result);
     result.appendFormat("Min idle refresh rate: %d\n", mMinIdleRefreshRate);
-    result.appendFormat("Refresh rate delay: %" PRId64 "ns\n\n", mRefreshRateDelayNanos);
+    result.appendFormat("Refresh rate delay: %" PRId64 " ns\n", mRefreshRateDelayNanos);
+    for (uint32_t i = 0; i < toUnderlying(DispIdleTimerRequester::MAX); i++) {
+        result.appendFormat("\t[%u] set to %" PRId64 " ns\n", i, mDisplayIdleTimerNanos[i]);
+    }
+    result.appendFormat("\n");
 }
 
 void ExynosPrimaryDisplay::calculateTimeline(
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
index 0c1df46..655194f 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.h
@@ -41,12 +41,14 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         virtual void setExpectedPresentTime(uint64_t timestamp);
         virtual uint64_t getPendingExpectedPresentTime();
         virtual void applyExpectedPresentTime();
+        virtual int32_t setDisplayIdleTimer(const int32_t timeoutMs) override;
 
         virtual void initDisplayInterface(uint32_t interfaceType);
         virtual int32_t doDisplayConfigInternal(hwc2_config_t config) override;
 
         virtual int setMinIdleRefreshRate(const int fps) override;
-        virtual int setRefreshRateThrottleNanos(const int64_t delayNs) override;
+        virtual int setRefreshRateThrottleNanos(const int64_t delayNs,
+                                                const DispIdleTimerRequester requester) override;
         virtual void dump(String8& result) override;
         virtual void updateAppliedActiveConfig(const hwc2_config_t newConfig,
                                                const int64_t ts) override;
@@ -84,6 +86,8 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         int32_t setPowerOff();
         int32_t setPowerDoze(hwc2_power_mode_t mode);
         void firstPowerOn();
+        int32_t setDisplayIdleTimerEnabled(const bool enabled);
+        int32_t getDisplayIdleTimerEnabled(bool& enabled);
 
         // LHBM
         FILE* mLhbmFd;
@@ -102,10 +106,14 @@ class ExynosPrimaryDisplay : public ExynosDisplay {
         void calculateTimeline(hwc2_config_t config,
                                hwc_vsync_period_change_constraints_t* vsyncPeriodChangeConstraints,
                                hwc_vsync_period_change_timeline_t* outTimeline) override;
+        std::mutex mIdleRefreshRateThrottleMutex;
         int mMinIdleRefreshRate;
         int64_t mRefreshRateDelayNanos;
         int64_t mLastRefreshRateAppliedNanos;
         hwc2_config_t mAppliedActiveConfig;
+
+        bool mDisplayIdleTimerEnabled;
+        int64_t mDisplayIdleTimerNanos[toUnderlying(DispIdleTimerRequester::MAX)];
 };
 
 #endif