Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2020 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 17 | #define LOG_TAG "HalWrapper" |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 18 | #include <android/hardware/power/Boost.h> |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 19 | #include <android/hardware/power/IPowerHintSession.h> |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 20 | #include <android/hardware/power/Mode.h> |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 21 | #include <powermanager/PowerHalWrapper.h> |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 22 | #include <utils/Log.h> |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 23 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 24 | #include <cinttypes> |
| 25 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 26 | using namespace android::hardware::power; |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 27 | namespace Aidl = android::hardware::power; |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 28 | |
| 29 | namespace android { |
| 30 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 31 | namespace power { |
| 32 | |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 33 | // ------------------------------------------------------------------------------------------------- |
| 34 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 35 | inline HalResult<void> toHalResult(const binder::Status& result) { |
Lais Andrade | 14e97b7 | 2020-07-14 12:27:44 +0000 | [diff] [blame] | 36 | if (result.isOk()) { |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 37 | return HalResult<void>::ok(); |
Lais Andrade | 14e97b7 | 2020-07-14 12:27:44 +0000 | [diff] [blame] | 38 | } |
| 39 | ALOGE("Power HAL request failed: %s", result.toString8().c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 40 | return HalResult<void>::fromStatus(result); |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 41 | } |
| 42 | |
| 43 | template <typename T> |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 44 | template <typename R> |
| 45 | HalResult<T> HalResult<T>::fromReturn(hardware::Return<R>& ret, T data) { |
| 46 | return ret.isOk() ? HalResult<T>::ok(data) : HalResult<T>::failed(ret.description()); |
| 47 | } |
| 48 | |
| 49 | template <typename T> |
| 50 | template <typename R> |
| 51 | HalResult<T> HalResult<T>::fromReturn(hardware::Return<R>& ret, V1_0::Status status, T data) { |
| 52 | return ret.isOk() ? HalResult<T>::fromStatus(status, data) |
| 53 | : HalResult<T>::failed(ret.description()); |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | // ------------------------------------------------------------------------------------------------- |
| 57 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 58 | HalResult<void> HalResult<void>::fromStatus(status_t status) { |
| 59 | if (status == android::OK) { |
| 60 | return HalResult<void>::ok(); |
| 61 | } |
| 62 | return HalResult<void>::failed(statusToString(status)); |
| 63 | } |
| 64 | |
| 65 | HalResult<void> HalResult<void>::fromStatus(binder::Status status) { |
| 66 | if (status.exceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) { |
| 67 | return HalResult<void>::unsupported(); |
| 68 | } |
| 69 | if (status.isOk()) { |
| 70 | return HalResult<void>::ok(); |
| 71 | } |
| 72 | return HalResult<void>::failed(std::string(status.toString8().c_str())); |
| 73 | } |
| 74 | |
| 75 | template <typename R> |
| 76 | HalResult<void> HalResult<void>::fromReturn(hardware::Return<R>& ret) { |
| 77 | return ret.isOk() ? HalResult<void>::ok() : HalResult<void>::failed(ret.description()); |
| 78 | } |
| 79 | // ------------------------------------------------------------------------------------------------- |
| 80 | |
| 81 | HalResult<void> EmptyHalWrapper::setBoost(Boost boost, int32_t durationMs) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 82 | ALOGV("Skipped setBoost %s with duration %dms because Power HAL not available", |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 83 | toString(boost).c_str(), durationMs); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 84 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 85 | } |
| 86 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 87 | HalResult<void> EmptyHalWrapper::setMode(Mode mode, bool enabled) { |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 88 | ALOGV("Skipped setMode %s to %s because Power HAL not available", toString(mode).c_str(), |
| 89 | enabled ? "true" : "false"); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 90 | return HalResult<void>::unsupported(); |
| 91 | } |
| 92 | |
| 93 | HalResult<sp<Aidl::IPowerHintSession>> EmptyHalWrapper::createHintSession( |
| 94 | int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) { |
| 95 | ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available", |
| 96 | threadIds.size()); |
| 97 | return HalResult<sp<Aidl::IPowerHintSession>>::unsupported(); |
| 98 | } |
| 99 | |
| 100 | HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() { |
| 101 | ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available"); |
| 102 | return HalResult<int64_t>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | // ------------------------------------------------------------------------------------------------- |
| 106 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 107 | HalResult<void> HidlHalWrapperV1_0::setBoost(Boost boost, int32_t durationMs) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 108 | if (boost == Boost::INTERACTION) { |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 109 | return sendPowerHint(V1_3::PowerHint::INTERACTION, durationMs); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 110 | } else { |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 111 | ALOGV("Skipped setBoost %s because Power HAL AIDL not available", toString(boost).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 112 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 113 | } |
| 114 | } |
| 115 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 116 | HalResult<void> HidlHalWrapperV1_0::setMode(Mode mode, bool enabled) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 117 | uint32_t data = enabled ? 1 : 0; |
| 118 | switch (mode) { |
| 119 | case Mode::LAUNCH: |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 120 | return sendPowerHint(V1_3::PowerHint::LAUNCH, data); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 121 | case Mode::LOW_POWER: |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 122 | return sendPowerHint(V1_3::PowerHint::LOW_POWER, data); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 123 | case Mode::SUSTAINED_PERFORMANCE: |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 124 | return sendPowerHint(V1_3::PowerHint::SUSTAINED_PERFORMANCE, data); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 125 | case Mode::VR: |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 126 | return sendPowerHint(V1_3::PowerHint::VR_MODE, data); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 127 | case Mode::INTERACTIVE: |
| 128 | return setInteractive(enabled); |
| 129 | case Mode::DOUBLE_TAP_TO_WAKE: |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 130 | return setFeature(V1_0::Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 131 | default: |
| 132 | ALOGV("Skipped setMode %s because Power HAL AIDL not available", |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 133 | toString(mode).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 134 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 135 | } |
| 136 | } |
| 137 | |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 138 | HalResult<void> HidlHalWrapperV1_0::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) { |
| 139 | auto ret = mHandleV1_0->powerHint(static_cast<V1_0::PowerHint>(hintId), data); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 140 | return HalResult<void>::fromReturn(ret); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 141 | } |
| 142 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 143 | HalResult<void> HidlHalWrapperV1_0::setInteractive(bool enabled) { |
| 144 | auto ret = mHandleV1_0->setInteractive(enabled); |
| 145 | return HalResult<void>::fromReturn(ret); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 146 | } |
| 147 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 148 | HalResult<void> HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) { |
| 149 | auto ret = mHandleV1_0->setFeature(feature, enabled); |
| 150 | return HalResult<void>::fromReturn(ret); |
| 151 | } |
| 152 | |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 153 | HalResult<sp<hardware::power::IPowerHintSession>> HidlHalWrapperV1_0::createHintSession( |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 154 | int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) { |
| 155 | ALOGV("Skipped createHintSession(task num=%zu) because Power HAL not available", |
| 156 | threadIds.size()); |
| 157 | return HalResult<sp<Aidl::IPowerHintSession>>::unsupported(); |
| 158 | } |
| 159 | |
| 160 | HalResult<int64_t> HidlHalWrapperV1_0::getHintSessionPreferredRate() { |
| 161 | ALOGV("Skipped getHintSessionPreferredRate because Power HAL not available"); |
| 162 | return HalResult<int64_t>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 163 | } |
| 164 | |
| 165 | // ------------------------------------------------------------------------------------------------- |
| 166 | |
Matt Buckley | c3894a4 | 2022-09-01 21:17:15 +0000 | [diff] [blame^] | 167 | HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) { |
| 168 | auto handle = static_cast<V1_1::IPower*>(mHandleV1_0.get()); |
| 169 | auto ret = handle->powerHintAsync(static_cast<V1_0::PowerHint>(hintId), data); |
| 170 | return HalResult<void>::fromReturn(ret); |
| 171 | } |
| 172 | |
| 173 | // ------------------------------------------------------------------------------------------------- |
| 174 | |
| 175 | HalResult<void> HidlHalWrapperV1_2::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) { |
| 176 | auto handle = static_cast<V1_2::IPower*>(mHandleV1_0.get()); |
| 177 | auto ret = handle->powerHintAsync_1_2(static_cast<V1_2::PowerHint>(hintId), data); |
| 178 | return HalResult<void>::fromReturn(ret); |
| 179 | } |
| 180 | |
| 181 | HalResult<void> HidlHalWrapperV1_2::setBoost(Boost boost, int32_t durationMs) { |
| 182 | switch (boost) { |
| 183 | case Boost::CAMERA_SHOT: |
| 184 | return sendPowerHint(V1_3::PowerHint::CAMERA_SHOT, durationMs); |
| 185 | case Boost::CAMERA_LAUNCH: |
| 186 | return sendPowerHint(V1_3::PowerHint::CAMERA_LAUNCH, durationMs); |
| 187 | default: |
| 188 | return HidlHalWrapperV1_1::setBoost(boost, durationMs); |
| 189 | } |
| 190 | } |
| 191 | |
| 192 | HalResult<void> HidlHalWrapperV1_2::setMode(Mode mode, bool enabled) { |
| 193 | uint32_t data = enabled ? 1 : 0; |
| 194 | switch (mode) { |
| 195 | case Mode::CAMERA_STREAMING_SECURE: |
| 196 | case Mode::CAMERA_STREAMING_LOW: |
| 197 | case Mode::CAMERA_STREAMING_MID: |
| 198 | case Mode::CAMERA_STREAMING_HIGH: |
| 199 | return sendPowerHint(V1_3::PowerHint::CAMERA_STREAMING, data); |
| 200 | case Mode::AUDIO_STREAMING_LOW_LATENCY: |
| 201 | return sendPowerHint(V1_3::PowerHint::AUDIO_LOW_LATENCY, data); |
| 202 | default: |
| 203 | return HidlHalWrapperV1_1::setMode(mode, enabled); |
| 204 | } |
| 205 | } |
| 206 | |
| 207 | // ------------------------------------------------------------------------------------------------- |
| 208 | |
| 209 | HalResult<void> HidlHalWrapperV1_3::setMode(Mode mode, bool enabled) { |
| 210 | uint32_t data = enabled ? 1 : 0; |
| 211 | if (mode == Mode::EXPENSIVE_RENDERING) { |
| 212 | return sendPowerHint(V1_3::PowerHint::EXPENSIVE_RENDERING, data); |
| 213 | } |
| 214 | return HidlHalWrapperV1_2::setMode(mode, enabled); |
| 215 | } |
| 216 | |
| 217 | HalResult<void> HidlHalWrapperV1_3::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) { |
| 218 | auto handle = static_cast<V1_3::IPower*>(mHandleV1_0.get()); |
| 219 | auto ret = handle->powerHintAsync_1_3(hintId, data); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 220 | return HalResult<void>::fromReturn(ret); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | // ------------------------------------------------------------------------------------------------- |
| 224 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 225 | HalResult<void> AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 226 | std::unique_lock<std::mutex> lock(mBoostMutex); |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 227 | size_t idx = static_cast<size_t>(boost); |
| 228 | |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 229 | // Quick return if boost is not supported by HAL |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 230 | if (idx >= mBoostSupportedArray.size() || mBoostSupportedArray[idx] == HalSupport::OFF) { |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 231 | ALOGV("Skipped setBoost %s because Power HAL doesn't support it", toString(boost).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 232 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 233 | } |
| 234 | |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 235 | if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 236 | bool isSupported = false; |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 237 | auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 238 | if (!isSupportedRet.isOk()) { |
Lais Andrade | 14e97b7 | 2020-07-14 12:27:44 +0000 | [diff] [blame] | 239 | ALOGE("Skipped setBoost %s because check support failed with: %s", |
| 240 | toString(boost).c_str(), isSupportedRet.toString8().c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 241 | // return HalResult::FAILED; |
| 242 | return HalResult<void>::fromStatus(isSupportedRet); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 243 | } |
| 244 | |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 245 | mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF; |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 246 | if (!isSupported) { |
| 247 | ALOGV("Skipped setBoost %s because Power HAL doesn't support it", |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 248 | toString(boost).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 249 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 250 | } |
| 251 | } |
| 252 | lock.unlock(); |
| 253 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 254 | return toHalResult(mHandle->setBoost(boost, durationMs)); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 255 | } |
| 256 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 257 | HalResult<void> AidlHalWrapper::setMode(Mode mode, bool enabled) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 258 | std::unique_lock<std::mutex> lock(mModeMutex); |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 259 | size_t idx = static_cast<size_t>(mode); |
| 260 | |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 261 | // Quick return if mode is not supported by HAL |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 262 | if (idx >= mModeSupportedArray.size() || mModeSupportedArray[idx] == HalSupport::OFF) { |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 263 | ALOGV("Skipped setMode %s because Power HAL doesn't support it", toString(mode).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 264 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 265 | } |
| 266 | |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 267 | if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) { |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 268 | bool isSupported = false; |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 269 | auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 270 | if (!isSupportedRet.isOk()) { |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 271 | return HalResult<void>::failed(isSupportedRet.toString8().c_str()); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Lais Andrade | 7b632a5 | 2020-12-03 21:07:48 +0000 | [diff] [blame] | 274 | mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF; |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 275 | if (!isSupported) { |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 276 | ALOGV("Skipped setMode %s because Power HAL doesn't support it", |
| 277 | toString(mode).c_str()); |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 278 | return HalResult<void>::unsupported(); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 279 | } |
| 280 | } |
| 281 | lock.unlock(); |
| 282 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 283 | return toHalResult(mHandle->setMode(mode, enabled)); |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 284 | } |
| 285 | |
Jimmy Shiu | 0b264bb | 2021-03-03 00:30:50 +0800 | [diff] [blame] | 286 | HalResult<sp<Aidl::IPowerHintSession>> AidlHalWrapper::createHintSession( |
| 287 | int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) { |
| 288 | sp<IPowerHintSession> appSession; |
| 289 | return HalResult<sp<Aidl::IPowerHintSession>>:: |
| 290 | fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession), |
| 291 | appSession); |
| 292 | } |
| 293 | |
| 294 | HalResult<int64_t> AidlHalWrapper::getHintSessionPreferredRate() { |
| 295 | int64_t rate = -1; |
| 296 | auto result = mHandle->getHintSessionPreferredRate(&rate); |
| 297 | return HalResult<int64_t>::fromStatus(result, rate); |
| 298 | } |
| 299 | |
Lais Andrade | 4d51f6c | 2020-03-25 10:58:31 +0000 | [diff] [blame] | 300 | // ------------------------------------------------------------------------------------------------- |
| 301 | |
Lais Andrade | b59a9b5 | 2020-05-07 17:23:42 +0100 | [diff] [blame] | 302 | } // namespace power |
| 303 | |
| 304 | } // namespace android |