MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sdm660-common: Nuke powerstats HAL

Browse source 
* Powerstats are so buggy lmao, it keeps error  android.hardware.power.stats@1.0-service.xiaomi_sdm660: Failed to getEnergyData

Signed-off-by: clarencelol <clarencekuiek@icloud.com>
Signed-off-by: pix106 <sbordenave@gmail.com>
This commit is contained in:
clarencelol 2022-03-09 18:36:28 +08:00 committed by pix106
parent ba258d8957
commit 68b51b59ee
13 changed files with 2 additions and 477 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
powerstats/Android.bp
View file

@ -1,32 +0,0 @@
//
// Copyright (C) 2018 The Android Open Source Project
//
// SPDX-License-Identifier: Apache-2.0
cc_binary {
name: "android.hardware.power.stats@1.0-service.xiaomi_sdm660",
relative_install_path: "hw",
vintf_fragments: ["android.hardware.power.stats@1.0-service.xiaomi_sdm660.xml"],
init_rc: ["android.hardware.power.stats@1.0-service.xiaomi_sdm660.rc"],
srcs: ["service.cpp",
"RailDataProvider.cpp",
],
cflags: [
"-Wall",
"-Werror",
],
static_libs: [
"libpixelpowerstats",
],
shared_libs: [
"libbase",
"libcutils",
"libhidlbase",
"libfmq",
"liblog",
"libutils",
"android.hardware.power.stats@1.0",
"pixelpowerstats_provider_aidl_interface-cpp",
"libbinder",
],
vendor: true,
}

285
powerstats/RailDataProvider.cpp
View file

@ -1,285 +0,0 @@
/*
* Copyright (C) 2018 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 "libpixelpowerstats"
#include <algorithm>
#include <thread>
#include <exception>
#include <inttypes.h>
#include <stdlib.h>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/properties.h>
#include <android-base/strings.h>
#include <android-base/stringprintf.h>
#include "RailDataProvider.h"
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
#define MAX_FILE_PATH_LEN 128
#define MAX_DEVICE_NAME_LEN 64
#define MAX_QUEUE_SIZE 8192
constexpr char kIioDirRoot[] = "/sys/bus/iio/devices/";
constexpr char kDeviceName[] = "microchip,pac1934";
constexpr char kDeviceType[] = "iio:device";
constexpr uint32_t MAX_SAMPLING_RATE = 10;
constexpr uint64_t WRITE_TIMEOUT_NS = 1000000000;
void RailDataProvider::findIioPowerMonitorNodes() {
struct dirent *ent;
int fd;
char devName[MAX_DEVICE_NAME_LEN];
char filePath[MAX_FILE_PATH_LEN];
DIR *iioDir = opendir(kIioDirRoot);
if (!iioDir) {
ALOGE("Error opening directory: %s, error: %d", kIioDirRoot, errno);
return;
}
while (ent = readdir(iioDir), ent) {
if (strcmp(ent->d_name, ".") != 0 &&
strcmp(ent->d_name, "..") != 0 &&
strlen(ent->d_name) > strlen(kDeviceType) &&
strncmp(ent->d_name, kDeviceType, strlen(kDeviceType)) == 0) {
snprintf(filePath, MAX_FILE_PATH_LEN, "%s/%s", ent->d_name, "name");
fd = openat(dirfd(iioDir), filePath, O_RDONLY);
if (fd < 0) {
ALOGW("Failed to open directory: %s, error: %d", filePath, errno);
continue;
}
if (read(fd, devName, MAX_DEVICE_NAME_LEN) < 0) {
ALOGW("Failed to read device name from file: %s(%d)",
filePath, fd);
close(fd);
continue;
}
if (strncmp(devName, kDeviceName, strlen(kDeviceName)) == 0) {
snprintf(filePath, MAX_FILE_PATH_LEN, "%s/%s", kIioDirRoot, ent->d_name);
mOdpm.devicePaths.push_back(filePath);
}
close(fd);
}
}
closedir(iioDir);
return;
}
size_t RailDataProvider::parsePowerRails() {
std::string data;
std::string railFileName;
std::string spsFileName;
uint32_t index = 0;
uint32_t samplingRate;
for (const auto &path : mOdpm.devicePaths) {
railFileName = path + "/enabled_rails";
spsFileName = path + "/sampling_rate";
if (!android::base::ReadFileToString(spsFileName, &data)) {
ALOGW("Error reading file: %s", spsFileName.c_str());
continue;
}
samplingRate = strtoul(data.c_str(), NULL, 10);
if (!samplingRate || samplingRate == ULONG_MAX) {
ALOGE("Error parsing: %s", spsFileName.c_str());
break;
}
if (!android::base::ReadFileToString(railFileName, &data)) {
ALOGW("Error reading file: %s", railFileName.c_str());
continue;
}
std::istringstream railNames(data);
std::string line;
while (std::getline(railNames, line)) {
std::vector<std::string> words = android::base::Split(line, ":");
if (words.size() == 2) {
mOdpm.railsInfo.emplace(words[0],
RailData {
.devicePath = path,
.index = index,
.subsysName = words[1],
.samplingRate = samplingRate
});
index++;
} else {
ALOGW("Unexpected format in file: %s", railFileName.c_str());
}
}
}
return index;
}
int RailDataProvider::parseIioEnergyNode(std::string devName) {
int ret = 0;
std::string data;
std::string fileName = devName + "/energy_value";
if (!android::base::ReadFileToString(fileName, &data)) {
ALOGE("Error reading file: %s", fileName.c_str());
return -1;
}
std::istringstream energyData(data);
std::string line;
uint64_t timestamp = 0;
bool timestampRead = false;
while (std::getline(energyData, line)) {
std::vector<std::string> words = android::base::Split(line, ",");
if (timestampRead == false) {
if (words.size() == 1) {
timestamp = strtoull(words[0].c_str(), NULL, 10);
if (timestamp == 0 || timestamp == ULLONG_MAX) {
ALOGW("Potentially wrong timestamp: %" PRIu64, timestamp);
}
timestampRead = true;
}
} else if (words.size() == 2) {
std::string railName = words[0];
if (mOdpm.railsInfo.count(railName) != 0) {
size_t index = mOdpm.railsInfo[railName].index;
mOdpm.reading[index].index = index;
mOdpm.reading[index].timestamp = timestamp;
mOdpm.reading[index].energy = strtoull(words[1].c_str(), NULL, 10);
if (mOdpm.reading[index].energy == ULLONG_MAX) {
ALOGW("Potentially wrong energy value: %" PRIu64,
mOdpm.reading[index].energy);
}
}
} else {
ALOGW("Unexpected format in file: %s", fileName.c_str());
ret = -1;
break;
}
}
return ret;
}
Status RailDataProvider::parseIioEnergyNodes() {
Status ret = Status::SUCCESS;
if (mOdpm.hwEnabled == false) {
return Status::NOT_SUPPORTED;
}
for (const auto &devicePath : mOdpm.devicePaths) {
if(parseIioEnergyNode(devicePath) < 0) {
ALOGE("Error in parsing power stats");
ret = Status::FILESYSTEM_ERROR;
break;
}
}
return ret;
}
RailDataProvider::RailDataProvider() {
findIioPowerMonitorNodes();
size_t numRails = parsePowerRails();
if (mOdpm.devicePaths.empty() || numRails == 0) {
mOdpm.hwEnabled = false;
} else {
mOdpm.hwEnabled = true;
mOdpm.reading.resize(numRails);
}
}
Return<void> RailDataProvider::getRailInfo(IPowerStats::getRailInfo_cb _hidl_cb) {
hidl_vec<RailInfo> rInfo;
Status ret = Status::SUCCESS;
size_t index;
std::lock_guard<std::mutex> _lock(mOdpm.mLock);
if (mOdpm.hwEnabled == false) {
ALOGI("getRailInfo not supported");
_hidl_cb(rInfo, Status::NOT_SUPPORTED);
return Void();
}
rInfo.resize(mOdpm.railsInfo.size());
for (const auto& railData : mOdpm.railsInfo) {
index = railData.second.index;
rInfo[index].railName = railData.first;
rInfo[index].subsysName = railData.second.subsysName;
rInfo[index].index = index;
rInfo[index].samplingRate = railData.second.samplingRate;
}
_hidl_cb(rInfo, ret);
return Void();
}
Return<void> RailDataProvider::getEnergyData(const hidl_vec<uint32_t>& railIndices, IPowerStats::getEnergyData_cb _hidl_cb) {
hidl_vec<EnergyData> eVal;
std::lock_guard<std::mutex> _lock(mOdpm.mLock);
Status ret = parseIioEnergyNodes();
if (ret != Status::SUCCESS) {
ALOGE("Failed to getEnergyData");
_hidl_cb(eVal, ret);
return Void();
}
if (railIndices.size() == 0) {
eVal.resize(mOdpm.railsInfo.size());
memcpy(&eVal[0], &mOdpm.reading[0], mOdpm.reading.size() * sizeof(EnergyData));
} else {
eVal.resize(railIndices.size());
int i = 0;
for (const auto &railIndex : railIndices) {
if (railIndex >= mOdpm.reading.size()) {
ret = Status::INVALID_INPUT;
eVal.resize(0);
break;
}
memcpy(&eVal[i], &mOdpm.reading[railIndex], sizeof(EnergyData));
i++;
}
}
_hidl_cb(eVal, ret);
return Void();
}
Return<void> RailDataProvider::streamEnergyData(uint32_t timeMs, uint32_t samplingRate,
IPowerStats::streamEnergyData_cb _hidl_cb) {
std::lock_guard<std::mutex> _lock(mOdpm.mLock);
if (mOdpm.fmqSynchronized != nullptr) {
_hidl_cb(MessageQueueSync::Descriptor(),
0, 0, Status::INSUFFICIENT_RESOURCES);
return Void();
}
uint32_t sps = std::min(samplingRate, MAX_SAMPLING_RATE);
uint32_t numSamples = timeMs * sps / 1000;
mOdpm.fmqSynchronized.reset(new (std::nothrow) MessageQueueSync(MAX_QUEUE_SIZE, true));
if (mOdpm.fmqSynchronized == nullptr || mOdpm.fmqSynchronized->isValid() == false) {
mOdpm.fmqSynchronized = nullptr;
_hidl_cb(MessageQueueSync::Descriptor(),
0, 0, Status::INSUFFICIENT_RESOURCES);
return Void();
}
std::thread pollThread = std::thread([this, sps, numSamples]() {
uint64_t sleepTimeUs = 1000000/sps;
uint32_t currSamples = 0;
while (currSamples < numSamples) {
mOdpm.mLock.lock();
if (parseIioEnergyNodes() == Status::SUCCESS) {
mOdpm.fmqSynchronized->writeBlocking(&mOdpm.reading[0],
mOdpm.reading.size(), WRITE_TIMEOUT_NS);
mOdpm.mLock.unlock();
currSamples++;
if (usleep(sleepTimeUs) < 0) {
ALOGW("Sleep interrupted");
break;
}
} else {
mOdpm.mLock.unlock();
break;
}
}
mOdpm.mLock.lock();
mOdpm.fmqSynchronized = nullptr;
mOdpm.mLock.unlock();
return;
});
pollThread.detach();
_hidl_cb(*(mOdpm.fmqSynchronized)->getDesc(), numSamples,
mOdpm.reading.size(), Status::SUCCESS);
return Void();
}
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android

46
powerstats/RailDataProvider.h
View file

@ -1,46 +0,0 @@
#ifndef ANDROID_HARDWARE_POWERSTATS_RAILDATAPROVIDER_H
#define ANDROID_HARDWARE_POWERSTATS_RAILDATAPROVIDER_H
#include <fmq/MessageQueue.h>
#include <pixelpowerstats/PowerStats.h>
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
typedef MessageQueue<EnergyData, kSynchronizedReadWrite> MessageQueueSync;
struct RailData {
std::string devicePath;
uint32_t index;
std::string subsysName;
uint32_t samplingRate;
};
struct OnDeviceMmt {
std::mutex mLock;
bool hwEnabled;
std::vector<std::string> devicePaths;
std::map<std::string, RailData> railsInfo;
std::vector<EnergyData> reading;
std::unique_ptr<MessageQueueSync> fmqSynchronized;
};
class RailDataProvider : public IRailDataProvider {
public:
RailDataProvider();
// Methods from ::android::hardware::power::stats::V1_0::IPowerStats follow.
Return<void> getRailInfo(IPowerStats::getRailInfo_cb _hidl_cb) override;
Return<void> getEnergyData(const hidl_vec<uint32_t>& railIndices,
IPowerStats::getEnergyData_cb _hidl_cb) override;
Return<void> streamEnergyData(uint32_t timeMs, uint32_t samplingRate,
IPowerStats::streamEnergyData_cb _hidl_cb) override;
private:
OnDeviceMmt mOdpm;
void findIioPowerMonitorNodes();
size_t parsePowerRails();
int parseIioEnergyNode(std::string devName);
Status parseIioEnergyNodes();
};
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_POWERSTATS_RAILDATAPROVIDER_H

4
powerstats/android.hardware.power.stats@1.0-service.xiaomi_sdm660.rc
View file

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

7
powerstats/android.hardware.power.stats@1.0-service.xiaomi_sdm660.xml
View file

@ -1,7 +0,0 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.power.stats</name>
<transport>hwbinder</transport>
<fqname>@1.0::IPowerStats/default</fqname>
</hal>
</manifest>

73
powerstats/service.cpp
View file

@ -1,73 +0,0 @@
/*
* Copyright (C) 2020 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.stats@1.0-service.xiaomi_sdm660"
#include <android-base/properties.h>
#include <android/log.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <hidl/HidlTransportSupport.h>
#include <pixelpowerstats/AidlStateResidencyDataProvider.h>
#include <pixelpowerstats/GenericStateResidencyDataProvider.h>
#include <pixelpowerstats/PowerStats.h>
#include "RailDataProvider.h"
using android::OK;
using android::sp;
using android::status_t;
// libhwbinder:
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
// Generated HIDL files
using android::hardware::power::stats::V1_0::IPowerStats;
using android::hardware::power::stats::V1_0::PowerEntityInfo;
using android::hardware::power::stats::V1_0::PowerEntityStateSpace;
using android::hardware::power::stats::V1_0::PowerEntityType;
using android::hardware::power::stats::V1_0::implementation::PowerStats;
// Pixel specific
using android::hardware::google::pixel::powerstats::AidlStateResidencyDataProvider;
using android::hardware::google::pixel::powerstats::GenericStateResidencyDataProvider;
using android::hardware::google::pixel::powerstats::RailDataProvider;
int main(int /* argc */, char ** /* argv */) {
ALOGI("power.stats service 1.0 is starting.");
PowerStats *service = new PowerStats();
// Add rail data provider
service->setRailDataProvider(std::make_unique<RailDataProvider>());
// Add Power Entities that require the Aidl data provider
sp<AidlStateResidencyDataProvider> aidlSdp = new AidlStateResidencyDataProvider();
uint32_t citadelId = service->addPowerEntity("Citadel", PowerEntityType::SUBSYSTEM);
aidlSdp->addEntity(citadelId, "Citadel", {"Last-Reset", "Active", "Deep-Sleep"});
auto serviceStatus = android::defaultServiceManager()->addService(
android::String16("power.stats-vendor"), aidlSdp);
if (serviceStatus != android::OK) {
ALOGE("Unable to register power.stats-vendor service %d", serviceStatus);
return 1;
}
sp<android::ProcessState> ps{android::ProcessState::self()}; // Create non-HW binder threadpool
ps->startThreadPool();
service->addStateResidencyDataProvider(aidlSdp);
// Configure the threadpool
configureRpcThreadpool(1, true /*callerWillJoin*/);
status_t status = service->registerAsService();
if (status != OK) {
ALOGE("Could not register service for power.stats HAL Iface (%d), exiting.", status);
return 1;
}
ALOGI("power.stats service is ready");
joinRpcThreadpool();
// In normal operation, we don't expect the thread pool to exit
ALOGE("power.stats service is shutting down");
return 1;
}

3
sdm660.mk
View file

@ -433,8 +433,7 @@ PRODUCT_PACKAGES += \
# Power
PRODUCT_PACKAGES += \
android.hardware.power-service.xiaomi_sdm660-libperfmgr \
android.hardware.power.stats@1.0-service.xiaomi_sdm660
android.hardware.power-service.xiaomi_sdm660-libperfmgr
# Powerhint
ifeq ($(EAS_POWERHINT_VARIANT), sdm636)

5
sepolicy/vendor/file.te vendored
View file

@ -25,8 +25,3 @@ type audio_socket, file_type;
# Battery Saver
type sysfs_battery_saver, fs_type, sysfs_type;
# Powerstats
type sysfs_iio_devices, fs_type, sysfs_type;
type sysfs_power_stats, sysfs_type, fs_type;
type sysfs_power_stats_ignore, sysfs_type, fs_type;

1
sepolicy/vendor/file_contexts vendored
View file

@ -67,7 +67,6 @@
# Power
/(vendor|system/vendor)/bin/hw/android\.hardware\.power-service\.xiaomi_sdm660-libperfmgr u:object_r:hal_power_default_exec:s0
/(vendor|system/vendor)/bin/hw/android\.hardware\.power\.stats@1\.0-service\.xiaomi_sdm660 u:object_r:hal_power_stats_default_exec:s0
# Root files
/proc/sys/fs/protected_regular u:object_r:proc:s0

4
sepolicy/vendor/genfs_contexts vendored
View file

@ -54,10 +54,6 @@ genfscon sysfs /devices/platform/soc/soc:qcom,mincpubw
genfscon sysfs /devices/platform/soc/soc:qcom,memlat-cpu0 u:object_r:sysfs_devfreq:s0
genfscon sysfs /devices/platform/soc/soc:qcom,memlat-cpu4 u:object_r:sysfs_devfreq:s0
# Powerstats
genfscon sysfs /bus/iio/devices u:object_r:sysfs_iio_devices:s0
genfscon sysfs /devices/platform/soc/800f000.qcom,spmi/spmi-0/spmi0-00/800f000.qcom,spmi:qcom,pm660@0:vadc@3100/iio:device0/name u:object_r:sysfs_power_stats_ignore:s0
# Touchpanel
genfscon sysfs /touchpanel u:object_r:sysfs_touchpanel:s0

17
sepolicy/vendor/hal_power_stats_default.te vendored
View file

@ -1,17 +1,2 @@
allow hal_power_stats_default sysfs:dir { open read };
allow hal_power_stats_default sysfs:file open;
allow hal_power_stats_default sysfs_kgsl:file { r_file_perms getattr };
# Needed to traverse odpm files
r_dir_file(hal_power_stats_default, sysfs_iio_devices)
# Needed to traverse platform low power stats
r_dir_file(hal_power_stats_default, sysfs_power_stats)
# The following folders are incidentally accessed by hal_power_stats_default and are not needed.
dontaudit hal_power_stats_default sysfs_power_stats_ignore:dir r_dir_perms;
dontaudit hal_power_stats_default sysfs_power_stats_ignore:file r_file_perms;
dontaudit hal_power_stats_default sysfs:file read;
vndbinder_use(hal_power_stats)
add_service(hal_power_stats_server, power_stats_service)
allow hal_power_stats_default sysfs:file { open read };

1
sepolicy/vendor/vndservice.te vendored
View file

@ -1 +0,0 @@
type power_stats_service, vndservice_manager_type;

1
sepolicy/vendor/vndservice_contexts vendored
View file

@ -1 +0,0 @@
power.stats-vendor u:object_r:power_stats_service:s0