Snap for 11157599 from a230a07fa931e97f616690ca2ad824f09575a74e to 24Q1-release

Change-Id: Ida01fc2e8d73d794729a8a1b2bf53cdf67bcee9c

5 files changed, 87 insertions, 13 deletions

diff --git a/libhwc2.1/libdevice/BrightnessController.cpp b/libhwc2.1/libdevice/BrightnessController.cpp
index 949fd1e..d8055ed 100644
--- a/libhwc2.1/libdevice/BrightnessController.cpp
+++ b/libhwc2.1/libdevice/BrightnessController.cpp
@@ -343,6 +343,14 @@ int BrightnessController::updateAclMode() {
         mAclMode.store(mAclModeDefault);
     }
 
+    if (applyAclViaSysfs() == HWC2_ERROR_NO_RESOURCES)
+        ALOGW("%s try to apply acl_mode when brightness changed", __func__);
+
+    return NO_ERROR;
+}
+
+int BrightnessController::applyAclViaSysfs() {
+    if (!mAclModeOfs.is_open()) return NO_ERROR;
     if (!mAclMode.is_dirty()) return NO_ERROR;
 
     mAclModeOfs.seekp(std::ios_base::beg);
@@ -376,6 +384,11 @@ int BrightnessController::processDisplayBrightness(float brightness, const nsecs
     }
 
     ATRACE_CALL();
+
+    /* update ACL */
+    if (applyAclViaSysfs() == HWC2_ERROR_NO_RESOURCES)
+        ALOGE("%s failed to apply acl_mode", __func__);
+
     if (!mBrightnessIntfSupported) {
         level = brightness < 0 ? 0 : static_cast<uint32_t>(brightness * mMaxBrightness + 0.5f);
         return applyBrightnessViaSysfs(level);
diff --git a/libhwc2.1/libdevice/BrightnessController.h b/libhwc2.1/libdevice/BrightnessController.h
index 50c209a..de2f72e 100644
--- a/libhwc2.1/libdevice/BrightnessController.h
+++ b/libhwc2.1/libdevice/BrightnessController.h
@@ -77,6 +77,7 @@ public:
     int processOperationRate(int32_t hz);
     bool isDbmSupported() { return mDbmSupported; }
     int applyPendingChangeViaSysfs(const nsecs_t vsyncNs);
+    int applyAclViaSysfs();
     bool validateLayerBrightness(float brightness);
 
     /**
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
index cc1a7e1..3495d01 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplay.cpp
@@ -492,27 +492,35 @@ int32_t ExynosPrimaryDisplay::setPowerMode(int32_t mode) {
                 mOperationRateManager->getTargetOperationRate());
     }
 
+    int32_t res = HWC2_ERROR_BAD_PARAMETER;
     switch (mode) {
         case HWC2_POWER_MODE_DOZE:
-        case HWC2_POWER_MODE_DOZE_SUSPEND:
+        case HWC2_POWER_MODE_DOZE_SUSPEND: {
             if (mode == HWC2_POWER_MODE_DOZE && mDisplayInterface->needRefreshOnLP()) {
                 ALOGI("Refresh before setting power doze.");
                 mDevice->onRefresh(mDisplayId);
             }
-            return setPowerDoze(static_cast<hwc2_power_mode_t>(mode));
+            res = setPowerDoze(static_cast<hwc2_power_mode_t>(mode));
+            break;
+        }
         case HWC2_POWER_MODE_OFF:
-            setPowerOff();
+            res = setPowerOff();
             break;
         case HWC2_POWER_MODE_ON:
-            setPowerOn();
+            res = setPowerOn();
             break;
         default:
-            return HWC2_ERROR_BAD_PARAMETER;
+            return res;
+    }
+    if (res != HWC2_ERROR_NONE) {
+        return res;
     }
 
     ExynosDisplay::updateRefreshRateHint();
-
-    return HWC2_ERROR_NONE;
+    if (mVariableRefreshRateController) {
+        mVariableRefreshRateController->setPowerMode(mode);
+    }
+    return res;
 }
 
 void ExynosPrimaryDisplay::firstPowerOn() {
diff --git a/libhwc2.1/libvrr/VariableRefreshRateController.cpp b/libhwc2.1/libvrr/VariableRefreshRateController.cpp
index 8f0af10..e382c00 100644
--- a/libhwc2.1/libvrr/VariableRefreshRateController.cpp
+++ b/libhwc2.1/libvrr/VariableRefreshRateController.cpp
@@ -72,7 +72,7 @@ VariableRefreshRateController::VariableRefreshRateController(ExynosDisplay* disp
 }
 
 VariableRefreshRateController::~VariableRefreshRateController() {
-    stopThread();
+    stopThread(true);
 
     const std::lock_guard<std::mutex> lock(mMutex);
     if (mLastPresentFence.has_value()) {
@@ -146,19 +146,65 @@ void VariableRefreshRateController::setEnable(bool isEnabled) {
     mCondition.notify_all();
 }
 
+void VariableRefreshRateController::setPowerMode(int32_t powerMode) {
+    ATRACE_CALL();
+    LOG(INFO) << "VrrController: Set power mode to " << powerMode;
+
+    {
+        const std::lock_guard<std::mutex> lock(mMutex);
+        if (mPowerMode == powerMode) {
+            return;
+        }
+        switch (powerMode) {
+            case HWC_POWER_MODE_OFF:
+            case HWC_POWER_MODE_DOZE:
+            case HWC_POWER_MODE_DOZE_SUSPEND: {
+                mState = VrrControllerState::kDisable;
+                dropEventLocked();
+                break;
+            }
+            case HWC_POWER_MODE_NORMAL: {
+                // We should transition from either HWC_POWER_MODE_OFF, HWC_POWER_MODE_DOZE, or
+                // HWC_POWER_MODE_DOZE_SUSPEND. At this point, there should be no pending events
+                // posted.
+                if (!mEventQueue.empty()) {
+                    LOG(WARNING) << "VrrController: there should be no pending event when resume "
+                                    "from power mode = "
+                                 << mPowerMode << " to power mode = " << powerMode;
+                }
+                mState = VrrControllerState::kRendering;
+                const auto& vrrConfig = mVrrConfigs[mVrrActiveConfig];
+                postEvent(VrrControllerEventType::kRenderingTimeout,
+                          getNowNs() + vrrConfig.notifyExpectedPresentConfig.TimeoutNs);
+                break;
+            }
+            default: {
+                LOG(ERROR) << "VrrController: Unknown power mode = " << powerMode;
+                return;
+            }
+        }
+        mPowerMode = powerMode;
+    }
+    mCondition.notify_all();
+}
+
 void VariableRefreshRateController::setVrrConfigurations(
         std::unordered_map<hwc2_config_t, VrrConfig_t> configs) {
     ATRACE_CALL();
 
+    for (const auto& it : configs) {
+        LOG(INFO) << "VrrController: set Vrr configuration id = " << it.first;
+    }
+
     const std::lock_guard<std::mutex> lock(mMutex);
     mVrrConfigs = std::move(configs);
 }
 
-void VariableRefreshRateController::stopThread() {
+void VariableRefreshRateController::stopThread(bool exit) {
     ATRACE_CALL();
     {
         const std::lock_guard<std::mutex> lock(mMutex);
-        mThreadExit = true;
+        mThreadExit = exit;
         mEnabled = false;
         mState = VrrControllerState::kDisable;
     }
@@ -172,6 +218,9 @@ void VariableRefreshRateController::onPresent(int fence) {
     ATRACE_CALL();
     {
         const std::lock_guard<std::mutex> lock(mMutex);
+        if (mState == VrrControllerState::kDisable) {
+            return;
+        }
         if (!mRecord.mPendingCurrentPresentTime.has_value()) {
             LOG(WARNING) << "VrrController: VrrController: Present without expected present time "
                             "information";
diff --git a/libhwc2.1/libvrr/VariableRefreshRateController.h b/libhwc2.1/libvrr/VariableRefreshRateController.h
index c28b388..796c1f7 100644
--- a/libhwc2.1/libvrr/VariableRefreshRateController.h
+++ b/libhwc2.1/libvrr/VariableRefreshRateController.h
@@ -50,12 +50,14 @@ public:
 
     void setEnable(bool isEnabled);
 
+    void setPowerMode(int32_t mode);
+
     void setVrrConfigurations(std::unordered_map<hwc2_config_t, VrrConfig_t> configs);
 
 private:
     static constexpr int kDefaultRingBufferCapacity = 128;
     static constexpr int64_t kDefaultWakeUpTimeInPowerSaving =
-            100 * (std::nano::den / std::milli::den); // 10 Hz = 100 ms
+            500 * (std::nano::den / std::milli::den); // 500 ms
     static constexpr int64_t SIGNAL_TIME_PENDING = INT64_MAX;
     static constexpr int64_t SIGNAL_TIME_INVALID = -1;
 
@@ -92,7 +94,7 @@ private:
 
         std::optional<PresentEvent> mNextExpectedPresentTime = std::nullopt;
         std::optional<PresentEvent> mPendingCurrentPresentTime = std::nullopt;
-        ;
+
         typedef RingBuffer<PresentEvent, kDefaultRingBufferCapacity> PresentTimeRecord;
         typedef RingBuffer<VsyncEvent, kDefaultRingBufferCapacity> VsyncRecord;
         PresentTimeRecord mPresentHistory;
@@ -169,7 +171,7 @@ private:
 
     void postEvent(VrrControllerEventType type, int64_t when);
 
-    void stopThread();
+    void stopThread(bool exit);
 
     // The core function of the VRR controller thread.
     void threadBody();
@@ -180,6 +182,7 @@ private:
     int mPendingFramesToInsert = 0;
     std::priority_queue<VrrControllerEvent> mEventQueue;
     VrrRecord mRecord;
+    int32_t mPowerMode = -1;
     VrrControllerState mState;
     hwc2_config_t mVrrActiveConfig;
     std::unordered_map<hwc2_config_t, VrrConfig_t> mVrrConfigs;