tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Remove default implementation for PowerHal 1.1" into oc-mr1-dev

Browse source
This commit is contained in:
TreeHugger Robot 2017-09-12 16:51:33 +00:00 committed by Android (Google) Code Review
commit 3822ffb138
6 changed files with 0 additions and 367 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
power/1.1/default/Android.bp
View file

@ -1,33 +0,0 @@
// Copyright (C) 2016 The Android Open Source 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.
cc_binary {
proprietary: true,
defaults: ["hidl_defaults"],
relative_install_path: "hw",
name: "android.hardware.power@1.1-service",
init_rc: ["android.hardware.power@1.1-service.rc"],
srcs: ["service.cpp" , "Power.cpp"],
shared_libs: [
"liblog",
"libdl",
"libutils",
"libhardware",
"libhidlbase",
"libhidltransport",
"android.hardware.power@1.0",
"android.hardware.power@1.1",
],
}

177
power/1.1/default/Power.cpp
View file

@ -1,177 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source 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.
*/
#define LOG_TAG "android.hardware.power@1.1-impl"
#include <log/log.h>
#include <hardware/hardware.h>
#include <hardware/power.h>
#include "Power.h"
namespace android {
namespace hardware {
namespace power {
namespace V1_1 {
namespace implementation {
using ::android::hardware::power::V1_0::Feature;
using ::android::hardware::power::V1_0::PowerHint;
using ::android::hardware::power::V1_0::PowerStatePlatformSleepState;
using ::android::hardware::power::V1_0::Status;
using ::android::hardware::power::V1_1::PowerStateSubsystem;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
Power::Power(power_module_t *module) : mModule(module) {
if (mModule)
mModule->init(mModule);
}
Power::~Power() {
delete(mModule);
}
// Methods from ::android::hardware::power::V1_0::IPower follow.
Return<void> Power::setInteractive(bool interactive) {
if (mModule->setInteractive)
mModule->setInteractive(mModule, interactive ? 1 : 0);
return Void();
}
Return<void> Power::powerHint(PowerHint hint, int32_t data) {
int32_t param = data;
if (mModule->powerHint) {
if (data)
mModule->powerHint(mModule, static_cast<power_hint_t>(hint), &param);
else
mModule->powerHint(mModule, static_cast<power_hint_t>(hint), NULL);
}
return Void();
}
Return<void> Power::setFeature(Feature feature, bool activate) {
if (mModule->setFeature)
mModule->setFeature(mModule, static_cast<feature_t>(feature),
activate ? 1 : 0);
return Void();
}
Return<void> Power::getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) {
hidl_vec<PowerStatePlatformSleepState> states;
ssize_t number_platform_modes;
size_t *voters = nullptr;
power_state_platform_sleep_state_t *legacy_states = nullptr;
int ret;
if (mModule->get_number_of_platform_modes == nullptr ||
mModule->get_voter_list == nullptr ||
mModule->get_platform_low_power_stats == nullptr)
{
_hidl_cb(states, Status::SUCCESS);
return Void();
}
number_platform_modes = mModule->get_number_of_platform_modes(mModule);
if (number_platform_modes)
{
if ((ssize_t) (SIZE_MAX / sizeof(size_t)) <= number_platform_modes) // overflow
goto done;
voters = new (std::nothrow) size_t [number_platform_modes];
if (voters == nullptr)
goto done;
ret = mModule->get_voter_list(mModule, voters);
if (ret != 0)
goto done;
if ((ssize_t) (SIZE_MAX / sizeof(power_state_platform_sleep_state_t))
<= number_platform_modes) // overflow
goto done;
legacy_states = new (std::nothrow)
power_state_platform_sleep_state_t [number_platform_modes];
if (legacy_states == nullptr)
goto done;
for (int i = 0; i < number_platform_modes; i++)
{
legacy_states[i].voters = nullptr;
legacy_states[i].voters = new power_state_voter_t [voters[i]];
if (legacy_states[i].voters == nullptr)
goto done;
}
ret = mModule->get_platform_low_power_stats(mModule, legacy_states);
if (ret != 0)
goto done;
states.resize(number_platform_modes);
for (int i = 0; i < number_platform_modes; i++)
{
power_state_platform_sleep_state_t& legacy_state = legacy_states[i];
PowerStatePlatformSleepState& state = states[i];
state.name = legacy_state.name;
state.residencyInMsecSinceBoot = legacy_state.residency_in_msec_since_boot;
state.totalTransitions = legacy_state.total_transitions;
state.supportedOnlyInSuspend = legacy_state.supported_only_in_suspend;
state.voters.resize(voters[i]);
for(size_t j = 0; j < voters[i]; j++)
{
state.voters[j].name = legacy_state.voters[j].name;
state.voters[j].totalTimeInMsecVotedForSinceBoot = legacy_state.voters[j].total_time_in_msec_voted_for_since_boot;
state.voters[j].totalNumberOfTimesVotedSinceBoot = legacy_state.voters[j].total_number_of_times_voted_since_boot;
}
}
}
done:
if (legacy_states)
{
for (int i = 0; i < number_platform_modes; i++)
{
if(legacy_states[i].voters)
delete(legacy_states[i].voters);
}
}
delete[] legacy_states;
delete[] voters;
_hidl_cb(states, Status::SUCCESS);
return Void();
}
// Methods from ::android::hardware::power::V1_1::IPower follow.
Return<void> Power::getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) {
hidl_vec<PowerStateSubsystem> subsystems;
ssize_t number_subsystems = 0;
//This API will report zero subsystems to support older devices
//For devices that support this API, they will have their own implementation
subsystems.resize(number_subsystems);
_hidl_cb(subsystems, Status::SUCCESS);
return Void();
}
Return<void> Power::powerHintAsync(PowerHint hint, int32_t data) {
// just call the normal power hint in this oneway function
return powerHint(hint, data);
}
} // namespace implementation
} // namespace V1_1
} // namespace power
} // namespace hardware
} // namespace android

63
power/1.1/default/Power.h
View file

@ -1,63 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source 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.
*/
#ifndef ANDROID_HARDWARE_POWER_V1_1_POWER_H
#define ANDROID_HARDWARE_POWER_V1_1_POWER_H
#include <android/hardware/power/1.1/IPower.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Status.h>
#include <hardware/power.h>
namespace android {
namespace hardware {
namespace power {
namespace V1_1 {
namespace implementation {
using ::android::hardware::power::V1_0::Feature;
using ::android::hardware::power::V1_0::PowerHint;
using ::android::hardware::power::V1_1::IPower;
using ::android::hardware::Return;
using ::android::hardware::Void;
struct Power : public IPower {
Power(power_module_t* module);
~Power();
// Methods from ::android::hardware::power::V1_0::IPower follow
Return<void> setInteractive(bool interactive) override;
Return<void> powerHint(PowerHint hint, int32_t data) override;
Return<void> setFeature(Feature feature, bool activate) override;
Return<void> getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) override;
// Methods from ::android::hardware::power::V1_1::IPower follow.
Return<void> getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) override;
Return<void> powerHintAsync(PowerHint hint, int32_t data) override;
// Methods from ::android::hidl::base::V1_0::IBase follow.
private:
power_module_t* mModule;
};
} // namespace implementation
} // namespace V1_1
} // namespace power
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_POWER_V1_1_POWER_H

4
power/1.1/default/android.hardware.power@1.1-service.rc
View file

@ -1,4 +0,0 @@
service power-hal-1-1 /vendor/bin/hw/android.hardware.power@1.1-service
class hal
user system
group system

89
power/1.1/default/service.cpp
View file

@ -1,89 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source 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.
*/
#define LOG_TAG "android.hardware.power@1.1-service"
#include <android/log.h>
#include <hidl/HidlTransportSupport.h>
#include <android/hardware/power/1.1/IPower.h>
#include <hardware/power.h>
#include "Power.h"
using android::sp;
using android::status_t;
using android::OK;
// libhwbinder:
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
// Generated HIDL files
using android::hardware::power::V1_1::IPower;
using android::hardware::power::V1_1::implementation::Power;
int main() {
status_t status;
android::sp<IPower> service = nullptr;
const hw_module_t* hw_module = nullptr;
power_module_t* power_module = nullptr;
int err;
ALOGI("Power HAL Service 1.1 (Default) is starting.");
err = hw_get_module(POWER_HARDWARE_MODULE_ID, &hw_module);
if (err) {
ALOGE("hw_get_module %s failed: %d", POWER_HARDWARE_MODULE_ID, err);
goto shutdown;
}
if (!hw_module->methods || !hw_module->methods->open) {
power_module = reinterpret_cast<power_module_t*>(
const_cast<hw_module_t*>(hw_module));
} else {
err = hw_module->methods->open(hw_module, POWER_HARDWARE_MODULE_ID,
reinterpret_cast<hw_device_t**>(&power_module));
if (err) {
ALOGE("Passthrough failed to load legacy HAL.");
goto shutdown;
}
}
service = new Power(power_module);
if (service == nullptr) {
ALOGE("Can not create an instance of Power HAL Iface, exiting.");
goto shutdown;
}
configureRpcThreadpool(1, true /*callerWillJoin*/);
status = service->registerAsService();
if (status != OK) {
ALOGE("Could not register service for Power HAL Iface (%d).", status);
goto shutdown;
}
ALOGI("Power Service is ready");
joinRpcThreadpool();
//Should not pass this line
shutdown:
// In normal operation, we don't expect the thread pool to exit
ALOGE("Power Service is shutting down");
return 1;
}

1
power/Android.bp
View file

@ -4,6 +4,5 @@ subdirs = [
"1.0/default",
"1.0/vts/functional",
"1.1",
"1.1/default",
"1.1/vts/functional",
]