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
17 #define LOG_TAG "HalWrapper"
18 #include <aidl/android/hardware/power/Boost.h>
19 #include <aidl/android/hardware/power/IPowerHintSession.h>
20 #include <aidl/android/hardware/power/Mode.h>
21 #include <aidl/android/hardware/power/SupportInfo.h>
22 #include <powermanager/HalResult.h>
23 #include <powermanager/PowerHalWrapper.h>
24 #include <utils/Log.h>
25
26 using namespace android::hardware::power;
27 namespace Aidl = aidl::android::hardware::power;
28
29 namespace android {
30
31 namespace power {
32
33 // -------------------------------------------------------------------------------------------------
34
setBoost(Aidl::Boost boost,int32_t durationMs)35 HalResult<void> EmptyHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
36 ALOGV("Skipped setBoost %s with duration %dms because %s", toString(boost).c_str(), durationMs,
37 getUnsupportedMessage());
38 return HalResult<void>::unsupported();
39 }
40
setMode(Aidl::Mode mode,bool enabled)41 HalResult<void> EmptyHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
42 ALOGV("Skipped setMode %s to %s because %s", toString(mode).c_str(), enabled ? "true" : "false",
43 getUnsupportedMessage());
44 return HalResult<void>::unsupported();
45 }
46
createHintSession(int32_t,int32_t,const std::vector<int32_t> & threadIds,int64_t)47 HalResult<std::shared_ptr<PowerHintSessionWrapper>> EmptyHalWrapper::createHintSession(
48 int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t) {
49 ALOGV("Skipped createHintSession(task num=%zu) because %s", threadIds.size(),
50 getUnsupportedMessage());
51 return HalResult<std::shared_ptr<PowerHintSessionWrapper>>::unsupported();
52 }
53
createHintSessionWithConfig(int32_t,int32_t,const std::vector<int32_t> & threadIds,int64_t,Aidl::SessionTag,Aidl::SessionConfig *)54 HalResult<std::shared_ptr<PowerHintSessionWrapper>> EmptyHalWrapper::createHintSessionWithConfig(
55 int32_t, int32_t, const std::vector<int32_t>& threadIds, int64_t, Aidl::SessionTag,
56 Aidl::SessionConfig*) {
57 ALOGV("Skipped createHintSessionWithConfig(task num=%zu) because %s", threadIds.size(),
58 getUnsupportedMessage());
59 return HalResult<std::shared_ptr<PowerHintSessionWrapper>>::unsupported();
60 }
61
getHintSessionPreferredRate()62 HalResult<int64_t> EmptyHalWrapper::getHintSessionPreferredRate() {
63 ALOGV("Skipped getHintSessionPreferredRate because %s", getUnsupportedMessage());
64 return HalResult<int64_t>::unsupported();
65 }
66
getSessionChannel(int,int)67 HalResult<Aidl::ChannelConfig> EmptyHalWrapper::getSessionChannel(int, int) {
68 ALOGV("Skipped getSessionChannel because %s", getUnsupportedMessage());
69 return HalResult<Aidl::ChannelConfig>::unsupported();
70 }
71
closeSessionChannel(int,int)72 HalResult<void> EmptyHalWrapper::closeSessionChannel(int, int) {
73 ALOGV("Skipped closeSessionChannel because %s", getUnsupportedMessage());
74 return HalResult<void>::unsupported();
75 }
76
getSupportInfo()77 HalResult<Aidl::SupportInfo> EmptyHalWrapper::getSupportInfo() {
78 ALOGV("Skipped getSupportInfo because %s", getUnsupportedMessage());
79 return HalResult<Aidl::SupportInfo>::unsupported();
80 }
81
getUnsupportedMessage()82 const char* EmptyHalWrapper::getUnsupportedMessage() {
83 return "Power HAL is not supported";
84 }
85
86 // -------------------------------------------------------------------------------------------------
87
setBoost(Aidl::Boost boost,int32_t durationMs)88 HalResult<void> HidlHalWrapperV1_0::setBoost(Aidl::Boost boost, int32_t durationMs) {
89 if (boost == Aidl::Boost::INTERACTION) {
90 return sendPowerHint(V1_3::PowerHint::INTERACTION, durationMs);
91 } else {
92 return EmptyHalWrapper::setBoost(boost, durationMs);
93 }
94 }
95
setMode(Aidl::Mode mode,bool enabled)96 HalResult<void> HidlHalWrapperV1_0::setMode(Aidl::Mode mode, bool enabled) {
97 uint32_t data = enabled ? 1 : 0;
98 switch (mode) {
99 case Aidl::Mode::LAUNCH:
100 return sendPowerHint(V1_3::PowerHint::LAUNCH, data);
101 case Aidl::Mode::LOW_POWER:
102 return sendPowerHint(V1_3::PowerHint::LOW_POWER, data);
103 case Aidl::Mode::SUSTAINED_PERFORMANCE:
104 return sendPowerHint(V1_3::PowerHint::SUSTAINED_PERFORMANCE, data);
105 case Aidl::Mode::VR:
106 return sendPowerHint(V1_3::PowerHint::VR_MODE, data);
107 case Aidl::Mode::INTERACTIVE:
108 return setInteractive(enabled);
109 case Aidl::Mode::DOUBLE_TAP_TO_WAKE:
110 return setFeature(V1_0::Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, enabled);
111 default:
112 return EmptyHalWrapper::setMode(mode, enabled);
113 }
114 }
115
sendPowerHint(V1_3::PowerHint hintId,uint32_t data)116 HalResult<void> HidlHalWrapperV1_0::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
117 auto ret = mHandleV1_0->powerHint(static_cast<V1_0::PowerHint>(hintId), data);
118 return HalResult<void>::fromReturn(ret);
119 }
120
setInteractive(bool enabled)121 HalResult<void> HidlHalWrapperV1_0::setInteractive(bool enabled) {
122 auto ret = mHandleV1_0->setInteractive(enabled);
123 return HalResult<void>::fromReturn(ret);
124 }
125
setFeature(V1_0::Feature feature,bool enabled)126 HalResult<void> HidlHalWrapperV1_0::setFeature(V1_0::Feature feature, bool enabled) {
127 auto ret = mHandleV1_0->setFeature(feature, enabled);
128 return HalResult<void>::fromReturn(ret);
129 }
130
getUnsupportedMessage()131 const char* HidlHalWrapperV1_0::getUnsupportedMessage() {
132 return "Power HAL AIDL is not supported";
133 }
134
135 // -------------------------------------------------------------------------------------------------
136
sendPowerHint(V1_3::PowerHint hintId,uint32_t data)137 HalResult<void> HidlHalWrapperV1_1::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
138 auto handle = static_cast<V1_1::IPower*>(mHandleV1_0.get());
139 auto ret = handle->powerHintAsync(static_cast<V1_0::PowerHint>(hintId), data);
140 return HalResult<void>::fromReturn(ret);
141 }
142
143 // -------------------------------------------------------------------------------------------------
144
sendPowerHint(V1_3::PowerHint hintId,uint32_t data)145 HalResult<void> HidlHalWrapperV1_2::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
146 auto handle = static_cast<V1_2::IPower*>(mHandleV1_0.get());
147 auto ret = handle->powerHintAsync_1_2(static_cast<V1_2::PowerHint>(hintId), data);
148 return HalResult<void>::fromReturn(ret);
149 }
150
setBoost(Aidl::Boost boost,int32_t durationMs)151 HalResult<void> HidlHalWrapperV1_2::setBoost(Aidl::Boost boost, int32_t durationMs) {
152 switch (boost) {
153 case Aidl::Boost::CAMERA_SHOT:
154 return sendPowerHint(V1_3::PowerHint::CAMERA_SHOT, durationMs);
155 case Aidl::Boost::CAMERA_LAUNCH:
156 return sendPowerHint(V1_3::PowerHint::CAMERA_LAUNCH, durationMs);
157 default:
158 return HidlHalWrapperV1_1::setBoost(boost, durationMs);
159 }
160 }
161
setMode(Aidl::Mode mode,bool enabled)162 HalResult<void> HidlHalWrapperV1_2::setMode(Aidl::Mode mode, bool enabled) {
163 uint32_t data = enabled ? 1 : 0;
164 switch (mode) {
165 case Aidl::Mode::CAMERA_STREAMING_SECURE:
166 case Aidl::Mode::CAMERA_STREAMING_LOW:
167 case Aidl::Mode::CAMERA_STREAMING_MID:
168 case Aidl::Mode::CAMERA_STREAMING_HIGH:
169 return sendPowerHint(V1_3::PowerHint::CAMERA_STREAMING, data);
170 case Aidl::Mode::AUDIO_STREAMING_LOW_LATENCY:
171 return sendPowerHint(V1_3::PowerHint::AUDIO_LOW_LATENCY, data);
172 default:
173 return HidlHalWrapperV1_1::setMode(mode, enabled);
174 }
175 }
176
177 // -------------------------------------------------------------------------------------------------
178
setMode(Aidl::Mode mode,bool enabled)179 HalResult<void> HidlHalWrapperV1_3::setMode(Aidl::Mode mode, bool enabled) {
180 uint32_t data = enabled ? 1 : 0;
181 if (mode == Aidl::Mode::EXPENSIVE_RENDERING) {
182 return sendPowerHint(V1_3::PowerHint::EXPENSIVE_RENDERING, data);
183 }
184 return HidlHalWrapperV1_2::setMode(mode, enabled);
185 }
186
sendPowerHint(V1_3::PowerHint hintId,uint32_t data)187 HalResult<void> HidlHalWrapperV1_3::sendPowerHint(V1_3::PowerHint hintId, uint32_t data) {
188 auto handle = static_cast<V1_3::IPower*>(mHandleV1_0.get());
189 auto ret = handle->powerHintAsync_1_3(hintId, data);
190 return HalResult<void>::fromReturn(ret);
191 }
192
193 // -------------------------------------------------------------------------------------------------
194
setBoost(Aidl::Boost boost,int32_t durationMs)195 HalResult<void> AidlHalWrapper::setBoost(Aidl::Boost boost, int32_t durationMs) {
196 std::unique_lock<std::mutex> lock(mBoostMutex);
197 size_t idx = static_cast<size_t>(boost);
198
199 // Quick return if boost is not supported by HAL
200 if (idx >= mBoostSupportedArray.size() || mBoostSupportedArray[idx] == HalSupport::OFF) {
201 ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(), getUnsupportedMessage());
202 return HalResult<void>::unsupported();
203 }
204
205 if (mBoostSupportedArray[idx] == HalSupport::UNKNOWN) {
206 bool isSupported = false;
207 auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported);
208 if (!isSupportedRet.isOk()) {
209 ALOGE("Skipped setBoost %s because check support failed with: %s",
210 toString(boost).c_str(), isSupportedRet.getDescription().c_str());
211 // return HalResult::FAILED;
212 return HalResult<void>::fromStatus(isSupportedRet);
213 }
214
215 mBoostSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
216 if (!isSupported) {
217 ALOGV("Skipped setBoost %s because %s", toString(boost).c_str(),
218 getUnsupportedMessage());
219 return HalResult<void>::unsupported();
220 }
221 }
222 lock.unlock();
223
224 return HalResult<void>::fromStatus(mHandle->setBoost(boost, durationMs));
225 }
226
setMode(Aidl::Mode mode,bool enabled)227 HalResult<void> AidlHalWrapper::setMode(Aidl::Mode mode, bool enabled) {
228 std::unique_lock<std::mutex> lock(mModeMutex);
229 size_t idx = static_cast<size_t>(mode);
230
231 // Quick return if mode is not supported by HAL
232 if (idx >= mModeSupportedArray.size() || mModeSupportedArray[idx] == HalSupport::OFF) {
233 ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
234 return HalResult<void>::unsupported();
235 }
236
237 if (mModeSupportedArray[idx] == HalSupport::UNKNOWN) {
238 bool isSupported = false;
239 auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported);
240 if (!isSupportedRet.isOk()) {
241 return HalResult<void>::failed(isSupportedRet.getDescription());
242 }
243
244 mModeSupportedArray[idx] = isSupported ? HalSupport::ON : HalSupport::OFF;
245 if (!isSupported) {
246 ALOGV("Skipped setMode %s because %s", toString(mode).c_str(), getUnsupportedMessage());
247 return HalResult<void>::unsupported();
248 }
249 }
250 lock.unlock();
251
252 return HalResult<void>::fromStatus(mHandle->setMode(mode, enabled));
253 }
254
createHintSession(int32_t tgid,int32_t uid,const std::vector<int32_t> & threadIds,int64_t durationNanos)255 HalResult<std::shared_ptr<PowerHintSessionWrapper>> AidlHalWrapper::createHintSession(
256 int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos) {
257 std::shared_ptr<Aidl::IPowerHintSession> appSession;
258 return HalResult<std::shared_ptr<PowerHintSessionWrapper>>::
259 fromStatus(mHandle->createHintSession(tgid, uid, threadIds, durationNanos, &appSession),
260 std::make_shared<PowerHintSessionWrapper>(std::move(appSession)));
261 }
262
createHintSessionWithConfig(int32_t tgid,int32_t uid,const std::vector<int32_t> & threadIds,int64_t durationNanos,Aidl::SessionTag tag,Aidl::SessionConfig * config)263 HalResult<std::shared_ptr<PowerHintSessionWrapper>> AidlHalWrapper::createHintSessionWithConfig(
264 int32_t tgid, int32_t uid, const std::vector<int32_t>& threadIds, int64_t durationNanos,
265 Aidl::SessionTag tag, Aidl::SessionConfig* config) {
266 std::shared_ptr<Aidl::IPowerHintSession> appSession;
267 return HalResult<std::shared_ptr<PowerHintSessionWrapper>>::
268 fromStatus(mHandle->createHintSessionWithConfig(tgid, uid, threadIds, durationNanos,
269 tag, config, &appSession),
270 std::make_shared<PowerHintSessionWrapper>(std::move(appSession)));
271 }
272
getHintSessionPreferredRate()273 HalResult<int64_t> AidlHalWrapper::getHintSessionPreferredRate() {
274 int64_t rate = -1;
275 auto result = mHandle->getHintSessionPreferredRate(&rate);
276 return HalResult<int64_t>::fromStatus(result, rate);
277 }
278
getSessionChannel(int tgid,int uid)279 HalResult<Aidl::ChannelConfig> AidlHalWrapper::getSessionChannel(int tgid, int uid) {
280 Aidl::ChannelConfig config;
281 auto result = mHandle->getSessionChannel(tgid, uid, &config);
282 return HalResult<Aidl::ChannelConfig>::fromStatus(result, std::move(config));
283 }
284
closeSessionChannel(int tgid,int uid)285 HalResult<void> AidlHalWrapper::closeSessionChannel(int tgid, int uid) {
286 return HalResult<void>::fromStatus(mHandle->closeSessionChannel(tgid, uid));
287 }
288
getSupportInfo()289 HalResult<Aidl::SupportInfo> AidlHalWrapper::getSupportInfo() {
290 Aidl::SupportInfo support;
291 auto result = mHandle->getSupportInfo(&support);
292 return HalResult<Aidl::SupportInfo>::fromStatus(result, std::move(support));
293 }
294
getUnsupportedMessage()295 const char* AidlHalWrapper::getUnsupportedMessage() {
296 return "Power HAL doesn't support it";
297 }
298
299 // -------------------------------------------------------------------------------------------------
300
301 } // namespace power
302
303 } // namespace android
304