Snap for 7274915 from 910d836685407079653786eb0152cafca394dbea to sc-release (0aae71fc) · Commits · e / os / android_frameworks_native

include/powermanager/PowerHalController.h

+9 −3

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@
		#include <android-base/thread_annotations.h>
		#include <android/hardware/power/Boost.h>
		#include <android/hardware/power/IPower.h>
		#include <android/hardware/power/IPowerHintSession.h>
		#include <android/hardware/power/Mode.h>
		#include <powermanager/PowerHalWrapper.h>

		@@ -54,8 +55,12 @@ public:

		void init();

		virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) override;
		virtual HalResult<int64_t> getHintSessionPreferredRate() override;

		private:
		std::mutex mConnectedHalMutex;
		@@ -67,7 +72,8 @@ private:
		const std::shared_ptr<HalWrapper> mDefaultHal = std::make_shared<EmptyHalWrapper>();

		std::shared_ptr<HalWrapper> initHal();
		HalResult processHalResult(HalResult result, const char* functionName);
		template <typename T>
		HalResult<T> processHalResult(HalResult<T> result, const char* functionName);
		};

		// -------------------------------------------------------------------------------------------------

include/powermanager/PowerHalWrapper.h

+105 −18

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <android/hardware/power/1.1/IPower.h>
		#include <android/hardware/power/Boost.h>
		#include <android/hardware/power/IPower.h>
		#include <android/hardware/power/IPowerHintSession.h>
		#include <android/hardware/power/Mode.h>

		namespace android {
		@@ -34,11 +35,81 @@ enum class HalSupport {
		OFF = 2,
		};

		// State of the Power HAL api call result.
		enum class HalResult {
		SUCCESSFUL = 0,
		FAILED = 1,
		UNSUPPORTED = 2,
		// Result of a call to the Power HAL wrapper, holding data if successful.
		template <typename T>
		class HalResult {
		public:
		static HalResult<T> ok(T value) { return HalResult(value); }
		static HalResult<T> failed(std::string msg) {
		return HalResult(std::move(msg), /* unsupported= */ false);
		}
		static HalResult<T> unsupported() { return HalResult("", /* unsupported= */ true); }

		static HalResult<T> fromStatus(binder::Status status, T data) {
		if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {
		return HalResult<T>::unsupported();
		}
		if (status.isOk()) {
		return HalResult<T>::ok(data);
		}
		return HalResult<T>::failed(std::string(status.toString8().c_str()));
		}
		static HalResult<T> fromStatus(hardware::power::V1_0::Status status, T data);

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, T data);

		template <typename R>
		static HalResult<T> fromReturn(hardware::Return<R>& ret, hardware::power::V1_0::Status status,
		T data);

		// This will throw std::bad_optional_access if this result is not ok.
		const T& value() const { return mValue.value(); }
		bool isOk() const { return !mUnsupported && mValue.has_value(); }
		bool isFailed() const { return !mUnsupported && !mValue.has_value(); }
		bool isUnsupported() const { return mUnsupported; }
		const char* errorMessage() const { return mErrorMessage.c_str(); }

		private:
		std::optional<T> mValue;
		std::string mErrorMessage;
		bool mUnsupported;

		explicit HalResult(T value)
		: mValue(std::make_optional(value)), mErrorMessage(), mUnsupported(false) {}
		explicit HalResult(std::string errorMessage, bool unsupported)
		: mValue(), mErrorMessage(std::move(errorMessage)), mUnsupported(unsupported) {}
		};

		// Empty result of a call to the Power HAL wrapper.
		template <>
		class HalResult<void> {
		public:
		static HalResult<void> ok() { return HalResult(); }
		static HalResult<void> failed(std::string msg) { return HalResult(std::move(msg)); }
		static HalResult<void> unsupported() { return HalResult(/* unsupported= */ true); }

		static HalResult<void> fromStatus(status_t status);
		static HalResult<void> fromStatus(binder::Status status);
		static HalResult<void> fromStatus(hardware::power::V1_0::Status status);

		template <typename R>
		static HalResult<void> fromReturn(hardware::Return<R>& ret);

		bool isOk() const { return !mUnsupported && !mFailed; }
		bool isFailed() const { return !mUnsupported && mFailed; }
		bool isUnsupported() const { return mUnsupported; }
		const char* errorMessage() const { return mErrorMessage.c_str(); }

		private:
		std::string mErrorMessage;
		bool mFailed;
		bool mUnsupported;

		explicit HalResult(bool unsupported = false)
		: mErrorMessage(), mFailed(false), mUnsupported(unsupported) {}
		explicit HalResult(std::string errorMessage)
		: mErrorMessage(std::move(errorMessage)), mFailed(true), mUnsupported(false) {}
		};

		// Wrapper for Power HAL handlers.
		@@ -46,8 +117,12 @@ class HalWrapper {
		public:
		virtual ~HalWrapper() = default;

		virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) = 0;
		virtual HalResult setMode(hardware::power::Mode mode, bool enabled) = 0;
		virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) = 0;
		virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) = 0;
		virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) = 0;
		virtual HalResult<int64_t> getHintSessionPreferredRate() = 0;
		};

		// Empty Power HAL wrapper that ignores all api calls.
		@@ -56,8 +131,12 @@ public:
		EmptyHalWrapper() = default;
		~EmptyHalWrapper() = default;

		virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) override;
		virtual HalResult<int64_t> getHintSessionPreferredRate() override;
		};

		// Wrapper for the HIDL Power HAL v1.0.
		@@ -67,16 +146,20 @@ public:
		: mHandleV1_0(std::move(Hal)) {}
		virtual ~HidlHalWrapperV1_0() = default;

		virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) override;
		virtual HalResult<int64_t> getHintSessionPreferredRate() override;

		protected:
		virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId, uint32_t data);
		virtual HalResult<void> sendPowerHint(hardware::power::V1_0::PowerHint hintId, uint32_t data);

		private:
		sp<hardware::power::V1_0::IPower> mHandleV1_0;
		HalResult setInteractive(bool enabled);
		HalResult setFeature(hardware::power::V1_0::Feature feature, bool enabled);
		HalResult<void> setInteractive(bool enabled);
		HalResult<void> setFeature(hardware::power::V1_0::Feature feature, bool enabled);
		};

		// Wrapper for the HIDL Power HAL v1.1.
		@@ -88,7 +171,7 @@ public:
		virtual ~HidlHalWrapperV1_1() = default;

		protected:
		virtual HalResult sendPowerHint(hardware::power::V1_0::PowerHint hintId,
		virtual HalResult<void> sendPowerHint(hardware::power::V1_0::PowerHint hintId,
		uint32_t data) override;

		private:
		@@ -101,8 +184,12 @@ public:
		explicit AidlHalWrapper(sp<hardware::power::IPower> handle) : mHandle(std::move(handle)) {}
		virtual ~AidlHalWrapper() = default;

		virtual HalResult setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<void> setBoost(hardware::power::Boost boost, int32_t durationMs) override;
		virtual HalResult<void> setMode(hardware::power::Mode mode, bool enabled) override;
		virtual HalResult<sp<hardware::power::IPowerHintSession>> createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds,
		int64_t durationNanos) override;
		virtual HalResult<int64_t> getHintSessionPreferredRate() override;

		private:
		// Control access to the boost and mode supported arrays.

services/powermanager/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -38,7 +38,7 @@ cc_library_shared {
		"libutils",
		"android.hardware.power@1.0",
		"android.hardware.power@1.1",
		"android.hardware.power-V1-cpp",
		"android.hardware.power-V2-cpp",
		],

		cflags: [

services/powermanager/PowerHalController.cpp

+20 −5

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		#include <android/hardware/power/1.1/IPower.h>
		#include <android/hardware/power/Boost.h>
		#include <android/hardware/power/IPower.h>
		#include <android/hardware/power/IPowerHintSession.h>
		#include <android/hardware/power/Mode.h>
		#include <powermanager/PowerHalController.h>
		#include <powermanager/PowerHalLoader.h>
		@@ -73,9 +74,10 @@ std::shared_ptr<HalWrapper> PowerHalController::initHal() {

		// Check if a call to Power HAL function failed; if so, log the failure and
		// invalidate the current Power HAL handle.
		HalResult PowerHalController::processHalResult(HalResult result, const char* fnName) {
		if (result == HalResult::FAILED) {
		ALOGE("%s() failed: power HAL service not available.", fnName);
		template <typename T>
		HalResult<T> PowerHalController::processHalResult(HalResult<T> result, const char* fnName) {
		if (result.isFailed()) {
		ALOGE("%s failed: %s", fnName, result.errorMessage());
		std::lock_guard<std::mutex> lock(mConnectedHalMutex);
		// Drop Power HAL handle. This will force future api calls to reconnect.
		mConnectedHal = nullptr;
		@@ -84,18 +86,31 @@ HalResult PowerHalController::processHalResult(HalResult result, const char* fnN
		return result;
		}

		HalResult PowerHalController::setBoost(Boost boost, int32_t durationMs) {
		HalResult<void> PowerHalController::setBoost(Boost boost, int32_t durationMs) {
		std::shared_ptr<HalWrapper> handle = initHal();
		auto result = handle->setBoost(boost, durationMs);
		return processHalResult(result, "setBoost");
		}

		HalResult PowerHalController::setMode(Mode mode, bool enabled) {
		HalResult<void> PowerHalController::setMode(Mode mode, bool enabled) {
		std::shared_ptr<HalWrapper> handle = initHal();
		auto result = handle->setMode(mode, enabled);
		return processHalResult(result, "setMode");
		}

		HalResult<sp<IPowerHintSession>> PowerHalController::createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {
		std::shared_ptr<HalWrapper> handle = initHal();
		auto result = handle->createHintSession(tgid, uid, threadIds, durationNanos);
		return processHalResult(result, "createHintSession");
		}

		HalResult<int64_t> PowerHalController::getHintSessionPreferredRate() {
		std::shared_ptr<HalWrapper> handle = initHal();
		auto result = handle->getHintSessionPreferredRate();
		return processHalResult(result, "getHintSessionPreferredRate");
		}

		} // namespace power

		} // namespace android

services/powermanager/PowerHalWrapper.cpp

+108 −34

Original line number	Diff line number	Diff line
		@@ -16,11 +16,17 @@

		#define LOG_TAG "HalWrapper"
		#include <android/hardware/power/Boost.h>
		#include <android/hardware/power/IPowerHintSession.h>
		#include <android/hardware/power/Mode.h>
		#include <powermanager/PowerHalWrapper.h>
		#include <utils/Log.h>

		#include <cinttypes>

		using namespace android::hardware::power;
		namespace V1_0 = android::hardware::power::V1_0;
		namespace V1_1 = android::hardware::power::V1_1;
		namespace Aidl = android::hardware::power;

		namespace android {

		@@ -28,49 +34,88 @@ namespace power {

		// -------------------------------------------------------------------------------------------------

		inline HalResult toHalResult(const binder::Status& result) {
		inline HalResult<void> toHalResult(const binder::Status& result) {
		if (result.isOk()) {
		return HalResult::SUCCESSFUL;
		return HalResult<void>::ok();
		}
		ALOGE("Power HAL request failed: %s", result.toString8().c_str());
		return HalResult::FAILED;
		return HalResult<void>::fromStatus(result);
		}

		template <typename T>
		inline HalResult toHalResult(const hardware::Return<T>& result) {
		if (result.isOk()) {
		return HalResult::SUCCESSFUL;
		template <typename R>
		HalResult<T> HalResult<T>::fromReturn(hardware::Return<R>& ret, T data) {
		return ret.isOk() ? HalResult<T>::ok(data) : HalResult<T>::failed(ret.description());
		}

		template <typename T>
		template <typename R>
		HalResult<T> HalResult<T>::fromReturn(hardware::Return<R>& ret, V1_0::Status status, T data) {
		return ret.isOk() ? HalResult<T>::fromStatus(status, data)
		: HalResult<T>::failed(ret.description());
		}

		// -------------------------------------------------------------------------------------------------

		HalResult<void> HalResult<void>::fromStatus(status_t status) {
		if (status == android::OK) {
		return HalResult<void>::ok();
		}
		return HalResult<void>::failed(statusToString(status));
		}

		HalResult<void> HalResult<void>::fromStatus(binder::Status status) {
		if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {
		return HalResult<void>::unsupported();
		}
		if (status.isOk()) {
		return HalResult<void>::ok();
		}
		ALOGE("Power HAL request failed: %s", result.description().c_str());
		return HalResult::FAILED;
		return HalResult<void>::failed(std::string(status.toString8().c_str()));
		}

		template <typename R>
		HalResult<void> HalResult<void>::fromReturn(hardware::Return<R>& ret) {
		return ret.isOk() ? HalResult<void>::ok() : HalResult<void>::failed(ret.description());
		}
		// -------------------------------------------------------------------------------------------------

		HalResult EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		HalResult<void> EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		ALOGV("Skipped setBoost %s with duration %dms because Power HAL not available",
		toString(boost).c_str(), durationMs);
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}

		HalResult EmptyHalWrapper::setMode(Mode mode, bool enabled) {
		HalResult<void> EmptyHalWrapper::setMode(Mode mode, bool enabled) {
		ALOGV("Skipped setMode %s to %s because Power HAL not available", toString(mode).c_str(),
		enabled ? "true" : "false");
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}

		HalResult<sp<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSession(
		int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) {
		ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available",
		threadIds.size());
		return HalResult<sp<Aidl::IPowerHintSession>>::unsupported();
		}

		HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() {
		ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available");
		return HalResult<int64_t>::unsupported();
		}

		// -------------------------------------------------------------------------------------------------

		HalResult HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) {
		HalResult<void> HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) {
		if (boost == Boost::INTERACTION) {
		return sendPowerHint(V1_0::PowerHint::INTERACTION, durationMs);
		} else {
		ALOGV("Skipped setBoost %s because Power HAL AIDL not available", toString(boost).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}
		}

		HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) {
		HalResult<void> HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) {
		uint32_t data = enabled ? 1 : 0;
		switch (mode) {
		case Mode::LAUNCH:
		@@ -88,38 +133,54 @@ HalResult HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) {
		default:
		ALOGV("Skipped setMode %s because Power HAL AIDL not available",
		toString(mode).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}
		}

		HalResult<void> HidlHalWrapperV1_0::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) {
		auto ret = mHandleV1_0->powerHint(hintId, data);
		return HalResult<void>::fromReturn(ret);
		}

		HalResult HidlHalWrapperV1_0::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) {
		return toHalResult(mHandleV1_0->powerHint(hintId, data));
		HalResult<void> HidlHalWrapperV1_0::setInteractive(bool enabled) {
		auto ret = mHandleV1_0->setInteractive(enabled);
		return HalResult<void>::fromReturn(ret);
		}

		HalResult HidlHalWrapperV1_0::setInteractive(bool enabled) {
		return toHalResult(mHandleV1_0->setInteractive(enabled));
		HalResult<void> HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) {
		auto ret = mHandleV1_0->setFeature(feature, enabled);
		return HalResult<void>::fromReturn(ret);
		}

		HalResult HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) {
		return toHalResult(mHandleV1_0->setFeature(feature, enabled));
		HalResult<sp<Aidl::IPowerHintSession>> HidlHalWrapperV1_0::createHintSession(
		int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) {
		ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available",
		threadIds.size());
		return HalResult<sp<Aidl::IPowerHintSession>>::unsupported();
		}

		HalResult<int64_t> HidlHalWrapperV1_0::getHintSessionPreferredRate() {
		ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available");
		return HalResult<int64_t>::unsupported();
		}

		// -------------------------------------------------------------------------------------------------

		HalResult HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) {
		return toHalResult(mHandleV1_1->powerHintAsync(hintId, data));
		HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_0::PowerHint hintId, uint32_t data) {
		auto ret = mHandleV1_1->powerHintAsync(hintId, data);
		return HalResult<void>::fromReturn(ret);
		}

		// -------------------------------------------------------------------------------------------------

		HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		HalResult<void> AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		std::unique_lock<std::mutex> lock(mBoostMutex);
		size_t idx = static_cast<size_t>(boost);

		// Quick return if boost is not supported by HAL
		if (idx >= mBoostSupportedArray.size() \|\| mBoostSupportedArray[idx] == HalSupport::OFF) {
		ALOGV("Skipped setBoost %s because Power HAL doesn't support it", toString(boost).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}

		if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) {
		@@ -128,14 +189,15 @@ HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		if (!isSupportedRet.isOk()) {
		ALOGE("Skipped setBoost %s because check support failed with: %s",
		toString(boost).c_str(), isSupportedRet.toString8().c_str());
		return HalResult::FAILED;
		// return HalResult::FAILED;
		return HalResult<void>::fromStatus(isSupportedRet);
		}

		mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
		if (!isSupported) {
		ALOGV("Skipped setBoost %s because Power HAL doesn't support it",
		toString(boost).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}
		}
		lock.unlock();
		@@ -143,30 +205,28 @@ HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) {
		return toHalResult(mHandle->setBoost(boost, durationMs));
		}

		HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) {
		HalResult<void> AidlHalWrapper::setMode(Mode mode, bool enabled) {
		std::unique_lock<std::mutex> lock(mModeMutex);
		size_t idx = static_cast<size_t>(mode);

		// Quick return if mode is not supported by HAL
		if (idx >= mModeSupportedArray.size() \|\| mModeSupportedArray[idx] == HalSupport::OFF) {
		ALOGV("Skipped setMode %s because Power HAL doesn't support it", toString(mode).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}

		if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) {
		bool isSupported = false;
		auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported);
		if (!isSupportedRet.isOk()) {
		ALOGE("Skipped setMode %s because check support failed with: %s",
		toString(mode).c_str(), isSupportedRet.toString8().c_str());
		return HalResult::FAILED;
		return HalResult<void>::failed(isSupportedRet.toString8().c_str());
		}

		mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
		if (!isSupported) {
		ALOGV("Skipped setMode %s because Power HAL doesn't support it",
		toString(mode).c_str());
		return HalResult::UNSUPPORTED;
		return HalResult<void>::unsupported();
		}
		}
		lock.unlock();
		@@ -174,6 +234,20 @@ HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) {
		return toHalResult(mHandle->setMode(mode, enabled));
		}

		HalResult<sp<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSession(
		int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {
		sp<IPowerHintSession> appSession;
		return HalResult<sp<Aidl::IPowerHintSession>>::
		fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession),
		appSession);
		}

		HalResult<int64_t> AidlHalWrapper::getHintSessionPreferredRate() {
		int64_t rate = -1;
		auto result = mHandle->getHintSessionPreferredRate(&rate);
		return HalResult<int64_t>::fromStatus(result, rate);
		}

		// -------------------------------------------------------------------------------------------------

		} // namespace power