"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"
],
}
--- /dev/null
+/*
+ * 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
--- /dev/null
+/*
+ * 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
\ No newline at end of file
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();
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");
}
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);
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;
std::unique_ptr<InteractionHandler> mInteractionHandler;
std::atomic<bool> mVRModeOn;
std::atomic<bool> mSustainedPerfModeOn;
+ std::atomic<PowerProfile> mCurrentPerfProfile;
};
} // namespace pixel
<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>
#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";
LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath;
}
+ // parse number of profiles
+ int32_t serviceNumPerfProfiles = android::base::GetIntProperty(kPowerHalProfileNumProp, 0);
+
// single thread
ABinderProcess_setThreadPoolMaxThreadCount(0);
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");
projects / GitHub / LineageOS / android_hardware_samsung.git / commitdiff