Revert "Revert "aidl: power-libperfmgr: Re-implement lineage perf hint""

This reverts commit 03a61ae886.

Reason for revert: r-perf-profiles has been merged.

Change-Id: I8e5cef59d03d7f6e571d6677f40b6a730120971c

aidl/power-libperfmgr/Android.bp

@@ -35,11 +35,13 @@ cc_binary {
         "libbinder_ndk",
         "libperfmgr",
         "pixel-power-ext-ndk_platform",
+        "vendor.lineage.power-ndk_platform",
     ],
     srcs: [
         "service.cpp",
         "Power.cpp",
         "PowerExt.cpp",
-        "InteractionHandler.cpp"
+        "InteractionHandler.cpp",
+        "LineagePower.cpp"
     ],
 }

aidl/power-libperfmgr/LineagePower.cpp

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "LineagePower.h"
+
+namespace aidl {
+namespace vendor {
+namespace lineage {
+namespace power {
+namespace impl {
+
+LineagePower::LineagePower(std::shared_ptr<Power> power, int32_t serviceNumPerfProfiles)
+    : mPower(power), mNumPerfProfiles(serviceNumPerfProfiles) {}
+
+
+ndk::ScopedAStatus LineagePower::getFeature(Feature feature, int* _aidl_return) {
+    switch (feature) {
+        case Feature::SUPPORTED_PROFILES:
+            *_aidl_return = mNumPerfProfiles;
+            break;
+        default:
+            *_aidl_return = -1;
+            break;
+    }
+    return ndk::ScopedAStatus::ok();
+}
+
+ndk::ScopedAStatus LineagePower::setBoost(Boost type, int durationMs) {
+    switch (type) {
+        case Boost::SET_PROFILE:
+            mPower->setProfile(static_cast<PowerProfile>(durationMs));
+            break;
+        default:
+            break;
+    }
+    return ndk::ScopedAStatus::ok();
+}
+
+}  // namespace impl
+}  // namespace power
+}  // namespace lineage
+}  // namespace vendor
+}  // namespace aidl

aidl/power-libperfmgr/LineagePower.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2021 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <aidl/vendor/lineage/power/BnPower.h>
+#include "Power.h"
+
+namespace aidl {
+namespace vendor {
+namespace lineage {
+namespace power {
+namespace impl {
+
+using aidl::google::hardware::power::impl::pixel::Power;
+using aidl::google::hardware::power::impl::pixel::PowerProfile;
+
+class LineagePower : public BnPower {
+  public:
+    LineagePower(std::shared_ptr<Power> power, int32_t serviceNumPerfProfiles);
+    ndk::ScopedAStatus getFeature(Feature feature, int* _aidl_return) override;
+    ndk::ScopedAStatus setBoost(Boost type, int durationMs) override;
+
+  private:
+    std::shared_ptr<Power> mPower;
+    int32_t mNumPerfProfiles;
+};
+
+}  // namespace impl
+}  // namespace power
+}  // namespace lineage
+}  // namespace vendor
+}  // namespace aidl

aidl/power-libperfmgr/Power.cpp

@@ -40,12 +40,14 @@ namespace pixel {
 constexpr char kPowerHalStateProp[] = "vendor.powerhal.state";
 constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio";
 constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering";
+constexpr char kPowerHalProfileProp[] = "vendor.powerhal.perf_profile";
 
 Power::Power(std::shared_ptr<HintManager> hm)
     : mHintManager(hm),
       mInteractionHandler(nullptr),
       mVRModeOn(false),
-      mSustainedPerfModeOn(false) {
+      mSustainedPerfModeOn(false),
+      mCurrentPerfProfile(PowerProfile::BALANCED) {
     mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager);
     mInteractionHandler->Init();
 
@@ -79,6 +81,21 @@ Power::Power(std::shared_ptr<HintManager> hm)
         mHintManager->DoHint("EXPENSIVE_RENDERING");
     }
 
+    state = ::android::base::GetProperty(kPowerHalProfileProp, "");
+    if (state == "POWER_SAVE") {
+        ALOGI("Initialize with POWER_SAVE profile");
+        setProfile(PowerProfile::POWER_SAVE);
+    } else if (state == "BIAS_POWER_SAVE") {
+        ALOGI("Initialize with BIAS_POWER_SAVE profile");
+        setProfile(PowerProfile::BIAS_POWER_SAVE);
+    } else if (state == "BIAS_PERFORMANCE") {
+        ALOGI("Initialize with BIAS_PERFORMANCE profile");
+        setProfile(PowerProfile::BIAS_PERFORMANCE);
+    } else if (state == "HIGH_PERFORMANCE") {
+        ALOGI("Initialize with HIGH_PERFORMANCE profile");
+        setProfile(PowerProfile::HIGH_PERFORMANCE);
+    }
+
     // Now start to take powerhint
     ALOGI("PowerHAL ready to process hints");
 }
@@ -190,6 +207,52 @@ ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) {
     return ndk::ScopedAStatus::ok();
 }
 
+ndk::ScopedAStatus Power::setProfile(PowerProfile profile) {
+    if (mCurrentPerfProfile == profile) {
+        return ndk::ScopedAStatus::ok();
+    }
+
+    // End previous perf profile hints
+    switch (mCurrentPerfProfile) {
+        case PowerProfile::POWER_SAVE:
+            mHintManager->EndHint("PROFILE_POWER_SAVE");
+            break;
+        case PowerProfile::BIAS_POWER_SAVE:
+            mHintManager->EndHint("PROFILE_BIAS_POWER_SAVE");
+            break;
+        case PowerProfile::BIAS_PERFORMANCE:
+            mHintManager->EndHint("PROFILE_BIAS_PERFORMANCE");
+            break;
+        case PowerProfile::HIGH_PERFORMANCE:
+            mHintManager->EndHint("PROFILE_HIGH_PERFORMANCE");
+            break;
+        default:
+            break;
+    }
+
+    // Apply perf profile hints
+    switch (profile) {
+        case PowerProfile::POWER_SAVE:
+            mHintManager->DoHint("PROFILE_POWER_SAVE");
+            break;
+        case PowerProfile::BIAS_POWER_SAVE:
+            mHintManager->DoHint("PROFILE_BIAS_POWER_SAVE");
+            break;
+        case PowerProfile::BIAS_PERFORMANCE:
+            mHintManager->DoHint("PROFILE_BIAS_PERFORMANCE");
+            break;
+        case PowerProfile::HIGH_PERFORMANCE:
+            mHintManager->DoHint("PROFILE_HIGH_PERFORMANCE");
+            break;
+        default:
+            break;
+    }
+
+    mCurrentPerfProfile = profile;
+
+    return ndk::ScopedAStatus::ok();
+}
+
 ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
     LOG(DEBUG) << "Power setBoost: " << toString(type) << " duration: " << durationMs;
     ATRACE_INT(toString(type).c_str(), durationMs);

aidl/power-libperfmgr/Power.h

@@ -37,11 +37,21 @@ using ::aidl::android::hardware::power::Boost;
 using ::aidl::android::hardware::power::Mode;
 using ::android::perfmgr::HintManager;
 
+enum PowerProfile {
+    POWER_SAVE = 0,
+    BALANCED,
+    HIGH_PERFORMANCE,
+    BIAS_POWER_SAVE,
+    BIAS_PERFORMANCE,
+    MAX
+};
+
 class Power : public ::aidl::android::hardware::power::BnPower {
   public:
     Power(std::shared_ptr<HintManager> hm);
     ndk::ScopedAStatus setMode(Mode type, bool enabled) override;
     ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override;
+    ndk::ScopedAStatus setProfile(PowerProfile profile);
     ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override;
     ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override;
     binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
@@ -51,6 +61,7 @@ class Power : public ::aidl::android::hardware::power::BnPower {
     std::unique_ptr<InteractionHandler> mInteractionHandler;
     std::atomic<bool> mVRModeOn;
     std::atomic<bool> mSustainedPerfModeOn;
+    std::atomic<PowerProfile> mCurrentPerfProfile;
 };
 
 }  // namespace pixel

aidl/power-libperfmgr/android.hardware.power-service.samsung.xml

@@ -3,4 +3,8 @@
         <name>android.hardware.power</name>
         <fqname>IPower/default</fqname>
     </hal>
+    <hal format="aidl" override="true">
+        <name>vendor.lineage.power</name>
+        <fqname>IPower/default</fqname>
+    </hal>
 </manifest>

aidl/power-libperfmgr/service.cpp

@@ -23,13 +23,16 @@
 #include <android/binder_manager.h>
 #include <android/binder_process.h>
 
+#include "LineagePower.h"
 #include "Power.h"
 #include "PowerExt.h"
 
 using aidl::google::hardware::power::impl::pixel::Power;
 using aidl::google::hardware::power::impl::pixel::PowerExt;
 using ::android::perfmgr::HintManager;
+using aidl::vendor::lineage::power::impl::LineagePower;
 
+constexpr char kPowerHalProfileNumProp[] = "vendor.powerhal.perf_profiles";
 constexpr char kPowerHalConfigPath[] = "/vendor/etc/powerhint.json";
 constexpr char kPowerHalInitProp[] = "vendor.powerhal.init";
 
@@ -42,6 +45,9 @@ int main() {
         LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath;
     }
 
+    // parse number of profiles
+    int32_t serviceNumPerfProfiles = android::base::GetIntProperty(kPowerHalProfileNumProp, 0);
+
     // single thread
     ABinderProcess_setThreadPoolMaxThreadCount(0);
 
@@ -58,7 +64,13 @@ int main() {
     const std::string instance = std::string() + Power::descriptor + "/default";
     binder_status_t status = AServiceManager_addService(pw->asBinder().get(), instance.c_str());
     CHECK(status == STATUS_OK);
-    LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is started.";
+
+    // lineage service
+    std::shared_ptr<LineagePower> lineagePw = ndk::SharedRefBase::make<LineagePower>(pw, serviceNumPerfProfiles);
+    const std::string lineageInstance = std::string() + LineagePower::descriptor + "/default";
+    binder_status_t lineageStatus = AServiceManager_addService(lineagePw->asBinder().get(), lineageInstance.c_str());
+    CHECK(lineageStatus == STATUS_OK);
+    LOG(INFO) << "Pixel Power HAL AIDL Service with Extension & Lineage Perf Profile is started.";
 
     std::thread initThread([&]() {
         ::android::base::WaitForProperty(kPowerHalInitProp, "1");