Evolution-X-Devices/device_google_bramble
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove powerstats to fix build break

Browse Source 
Change-Id: Ib193e180005c20a3f12800d1ea55e9110a315a36
This commit is contained in:
Roger Liao
2019-08-07 19:53:23 +08:00
parent 43f1ae3ee4
commit c206b2cbb9
9 changed files with 0 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
powerstats/Android.bp
View File

@@ -1,46 +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.
cc_binary {
name: "android.hardware.power.stats@1.0-service.pixel",
include_dirs: ["hardware/knowles/athletico/sound_trigger_hal"],
relative_install_path: "hw",
init_rc: ["android.hardware.power.stats@1.0-service.pixel.rc"],
srcs: [
"service.cpp",
"RailDataProvider.cpp",
"GpuStateResidencyDataProvider.cpp",
"OsloStateResidencyDataProvider.cpp",
],
cflags: [
"-Wall",
"-Werror",
],
static_libs: [
"libpixelpowerstats",
],
shared_libs: [
"libbase",
"libcutils",
"libfmq",
"libhidlbase",
"libhidltransport",
"liblog",
"libutils",
"android.hardware.power.stats@1.0",
"pixelpowerstats_provider_aidl_interface-cpp",
"libbinder",
],
vendor: true,
}

96
powerstats/GpuStateResidencyDataProvider.cpp
View File

@@ -1,96 +0,0 @@
/*
* Copyright (C) 2019 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 "GpuStateResidencyDataProvider.h"
#include <android-base/logging.h>
#include <fstream>
#include <sstream>
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
GpuStateResidencyDataProvider::GpuStateResidencyDataProvider(uint32_t id)
: mPowerEntityId(id), mActiveId(0) /* (TODO (b/117228832): enable this) , mSuspendId(1) */ {}
bool GpuStateResidencyDataProvider::getTotalTime(const std::string &path, uint64_t &totalTimeMs) {
std::ifstream inFile(path, std::ifstream::in);
if (!inFile.is_open()) {
PLOG(ERROR) << __func__ << ":Failed to open file " << path;
return false;
}
std::string line;
std::getline(inFile, line);
std::istringstream lineStream(line, std::istringstream::in);
totalTimeMs = 0;
uint64_t curTimeMs = 0;
while (lineStream >> curTimeMs) {
totalTimeMs += curTimeMs;
}
return true;
}
bool GpuStateResidencyDataProvider::getResults(
std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) {
uint64_t totalActiveTimeUs = 0;
if (!getTotalTime("/sys/class/kgsl/kgsl-3d0/gpu_clock_stats", totalActiveTimeUs)) {
LOG(ERROR) << __func__ << "Failed to get results for GPU:Active";
return false;
}
/* (TODO (b/117228832): enable this)
uint64_t totalSuspendTimeMs = 0;
if (!getTotalTime("/sys/class/kgsl/kgsl-3d0/devfreq/suspend_time", totalSuspendTimeMs)) {
LOG(ERROR) << __func__ << "Failed to get results for GPU:Suspend";
return false;
}
*/
PowerEntityStateResidencyResult result = {
.powerEntityId = mPowerEntityId,
.stateResidencyData = {
{.powerEntityStateId = mActiveId, .totalTimeInStateMs = totalActiveTimeUs / 1000},
/* (TODO (b/117228832): enable this)
{.powerEntityStateId = mSuspendId, .totalTimeInStateMs = totalSuspendTimeMs},
*/
}};
results.emplace(std::make_pair(mPowerEntityId, result));
return true;
}
std::vector<PowerEntityStateSpace> GpuStateResidencyDataProvider::getStateSpaces() {
return {{.powerEntityId = mPowerEntityId,
.states = {
{.powerEntityStateId = mActiveId, .powerEntityStateName = "Active"},
/* (TODO (b/117228832): enable this)
{.powerEntityStateId = mSuspendId, .powerEntityStateName = "Suspend"}
*/
}}};
}
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android

51
powerstats/GpuStateResidencyDataProvider.h
View File

@@ -1,51 +0,0 @@
/*
* Copyright (C) 2019 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 HARDWARE_GOOGLE_PIXEL_POWERSTATS_GPUSTATERESIDENCYDATAPROVIDER_H
#define HARDWARE_GOOGLE_PIXEL_POWERSTATS_GPUSTATERESIDENCYDATAPROVIDER_H
#include <pixelpowerstats/PowerStats.h>
using android::hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
using android::hardware::power::stats::V1_0::PowerEntityStateSpace;
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
class GpuStateResidencyDataProvider : public IStateResidencyDataProvider {
public:
GpuStateResidencyDataProvider(uint32_t id);
~GpuStateResidencyDataProvider() = default;
bool getResults(
std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) override;
std::vector<PowerEntityStateSpace> getStateSpaces() override;
private:
bool getTotalTime(const std::string &path, uint64_t &totalTimeMs);
const uint32_t mPowerEntityId;
const uint32_t mActiveId;
/* (TODO (b/117228832): enable this) const uint32_t mSuspendId; */
};
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android
#endif // HARDWARE_GOOGLE_PIXEL_POWERSTATS_GPUSTATERESIDENCYDATAPROVIDER_H

97
powerstats/OsloStateResidencyDataProvider.cpp
View File

@@ -1,97 +0,0 @@
/*
* Copyright (C) 2019 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 "OsloStateResidencyDataProvider.h"
#include <android-base/logging.h>
#include <android-base/unique_fd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <utility>
#include "iaxxx-module.h"
#include "tests/oslo_iaxxx_sensor_control.h"
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
OsloStateResidencyDataProvider::OsloStateResidencyDataProvider(uint32_t id)
: mPath("/dev/iaxxx-module-celldrv"), mPowerEntityId(id) {}
bool OsloStateResidencyDataProvider::getResults(
std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) {
android::base::unique_fd devNode(open(mPath.c_str(), O_RDWR));
if (devNode.get() < 0) {
PLOG(ERROR) << __func__ << ":Failed to open file " << mPath;
return false;
}
int err = 0;
struct iaxxx_sensor_param sp = {
.inst_id = 0, .block_id = 0, .param_id = SENSOR_PARAM_DUMP_STATS, .param_val = 1};
err = ioctl(devNode.get(), MODULE_SENSOR_SET_PARAM, (unsigned long)&sp);
if (err) {
PLOG(ERROR) << __func__ << ": MODULE_SENSOR_SET_PARAM IOCTL failed";
return false;
}
struct iaxxx_sensor_mode_stats stats[SENSOR_NUM_MODE];
err = ioctl(devNode.get(), IAXXX_SENSOR_MODE_STATS, (unsigned long)stats);
if (err) {
PLOG(ERROR) << __func__ << ": IAXXX_SENSOR_MODE_STATS IOCTL failed";
return false;
}
PowerEntityStateResidencyResult result = {
.powerEntityId = mPowerEntityId,
.stateResidencyData = {
{.powerEntityStateId = SENSOR_MODE_OFF,
.totalTimeInStateMs = stats[SENSOR_MODE_OFF].totalTimeSpentMs,
.totalStateEntryCount = stats[SENSOR_MODE_OFF].totalNumEntries,
.lastEntryTimestampMs = stats[SENSOR_MODE_OFF].lastEntryTimeStampMs},
{.powerEntityStateId = SENSOR_MODE_ENTRANCE,
.totalTimeInStateMs = stats[SENSOR_MODE_ENTRANCE].totalTimeSpentMs,
.totalStateEntryCount = stats[SENSOR_MODE_ENTRANCE].totalNumEntries,
.lastEntryTimestampMs = stats[SENSOR_MODE_ENTRANCE].lastEntryTimeStampMs},
{.powerEntityStateId = SENSOR_MODE_INTERACTIVE,
.totalTimeInStateMs = stats[SENSOR_MODE_INTERACTIVE].totalTimeSpentMs,
.totalStateEntryCount = stats[SENSOR_MODE_INTERACTIVE].totalNumEntries,
.lastEntryTimestampMs = stats[SENSOR_MODE_INTERACTIVE].lastEntryTimeStampMs}}};
results.insert(std::make_pair(mPowerEntityId, result));
return true;
}
std::vector<PowerEntityStateSpace> OsloStateResidencyDataProvider::getStateSpaces() {
return {{.powerEntityId = mPowerEntityId,
.states = {
{.powerEntityStateId = SENSOR_MODE_OFF, .powerEntityStateName = "Off"},
{.powerEntityStateId = SENSOR_MODE_ENTRANCE, .powerEntityStateName = "Entrance"},
{.powerEntityStateId = SENSOR_MODE_INTERACTIVE,
.powerEntityStateName = "Interactive"}}}};
}
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android

47
powerstats/OsloStateResidencyDataProvider.h
View File

@@ -1,47 +0,0 @@
/*
* Copyright (C) 2019 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 HARDWARE_GOOGLE_PIXEL_POWERSTATS_OSLOSTATERESIDENCYDATAPROVIDER_H
#define HARDWARE_GOOGLE_PIXEL_POWERSTATS_OSLOSTATERESIDENCYDATAPROVIDER_H
#include <pixelpowerstats/PowerStats.h>
#include <unordered_map>
namespace android {
namespace hardware {
namespace google {
namespace pixel {
namespace powerstats {
class OsloStateResidencyDataProvider : public IStateResidencyDataProvider {
public:
OsloStateResidencyDataProvider(uint32_t id);
~OsloStateResidencyDataProvider() = default;
bool getResults(std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) override;
std::vector<PowerEntityStateSpace> getStateSpaces() override;
private:
const std::string mPath;
const uint32_t mPowerEntityId;
};
} // namespace powerstats
} // namespace pixel
} // namespace google
} // namespace hardware
} // namespace android
#endif // HARDWARE_GOOGLE_PIXEL_POWERSTATS_OSLOSTATERESIDENCYDATAPROVIDER_H

302
powerstats/RailDataProvider.cpp
View File

@@ -1,302 +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.
*/
#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", kIioDirRoot);
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", filePath);
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) {
_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

53
powerstats/RailDataProvider.h
View File

@@ -1,53 +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.pixel.rc
View File

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

234
powerstats/service.cpp
View File

@@ -1,234 +0,0 @@
/*
* Copyright (C) 2019 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.pixel"
#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 <pixelpowerstats/WlanStateResidencyDataProvider.h>
#include "GpuStateResidencyDataProvider.h"
#include "OsloStateResidencyDataProvider.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::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::generateGenericStateResidencyConfigs;
using android::hardware::google::pixel::powerstats::GenericStateResidencyDataProvider;
using android::hardware::google::pixel::powerstats::GpuStateResidencyDataProvider;
using android::hardware::google::pixel::powerstats::OsloStateResidencyDataProvider;
using android::hardware::google::pixel::powerstats::PowerEntityConfig;
using android::hardware::google::pixel::powerstats::RailDataProvider;
using android::hardware::google::pixel::powerstats::StateResidencyConfig;
using android::hardware::google::pixel::powerstats::WlanStateResidencyDataProvider;
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 related to rpmh
const uint64_t RPM_CLK = 19200; // RPM runs at 19.2Mhz. Divide by 19200 for msec
std::function<uint64_t(uint64_t)> rpmConvertToMs = [](uint64_t a) { return a / RPM_CLK; };
std::vector<StateResidencyConfig> rpmStateResidencyConfigs = {
{.name = "Sleep",
.entryCountSupported = true,
.entryCountPrefix = "Sleep Count:",
.totalTimeSupported = true,
.totalTimePrefix = "Sleep Accumulated Duration:",
.totalTimeTransform = rpmConvertToMs,
.lastEntrySupported = true,
.lastEntryPrefix = "Sleep Last Entered At:",
.lastEntryTransform = rpmConvertToMs}};
sp<GenericStateResidencyDataProvider> rpmSdp =
new GenericStateResidencyDataProvider("/sys/power/rpmh_stats/master_stats");
uint32_t apssId = service->addPowerEntity("APSS", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(apssId, PowerEntityConfig("APSS", rpmStateResidencyConfigs));
uint32_t mpssId = service->addPowerEntity("MPSS", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(mpssId, PowerEntityConfig("MPSS", rpmStateResidencyConfigs));
uint32_t adspId = service->addPowerEntity("ADSP", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(adspId, PowerEntityConfig("ADSP", rpmStateResidencyConfigs));
uint32_t cdspId = service->addPowerEntity("CDSP", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(cdspId, PowerEntityConfig("CDSP", rpmStateResidencyConfigs));
uint32_t slpiId = service->addPowerEntity("SLPI", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(slpiId, PowerEntityConfig("SLPI", rpmStateResidencyConfigs));
uint32_t slpiIslandId = service->addPowerEntity("SLPI_ISLAND", PowerEntityType::SUBSYSTEM);
rpmSdp->addEntity(slpiIslandId, PowerEntityConfig("SLPI_ISLAND", {
{.name = "uImage",
.entryCountSupported = true,
.entryCountPrefix = "Sleep Count:",
.totalTimeSupported = true,
.totalTimePrefix = "Sleep Accumulated Duration:",
.totalTimeTransform = rpmConvertToMs,
.lastEntrySupported = true,
.lastEntryPrefix = "Sleep Last Entered At:",
.lastEntryTransform = rpmConvertToMs}}));
service->addStateResidencyDataProvider(rpmSdp);
// Add SoC power entity
StateResidencyConfig socStateConfig = {
.entryCountSupported = true,
.entryCountPrefix = "count:",
.totalTimeSupported = true,
.totalTimePrefix = "actual last sleep(msec):",
.lastEntrySupported = false
};
std::vector<std::pair<std::string, std::string>> socStateHeaders = {
std::make_pair("AOSD", "RPM Mode:aosd"),
std::make_pair("CXSD", "RPM Mode:cxsd"),
std::make_pair("DDR", "RPM Mode:ddr"),
};
sp<GenericStateResidencyDataProvider> socSdp =
new GenericStateResidencyDataProvider("/sys/power/system_sleep/stats");
uint32_t socId = service->addPowerEntity("SoC", PowerEntityType::POWER_DOMAIN);
socSdp->addEntity(socId,
PowerEntityConfig(generateGenericStateResidencyConfigs(socStateConfig, socStateHeaders)));
service->addStateResidencyDataProvider(socSdp);
// Add WLAN power entity
uint32_t wlanId = service->addPowerEntity("WLAN", PowerEntityType::SUBSYSTEM);
sp<WlanStateResidencyDataProvider> wlanSdp =
new WlanStateResidencyDataProvider(wlanId, "/sys/kernel/wlan/power_stats");
service->addStateResidencyDataProvider(wlanSdp);
// Add Airbrush power entity
StateResidencyConfig airStateConfig = {
.entryCountSupported = true,
.entryCountPrefix = "Cumulative count:",
.totalTimeSupported = true,
.totalTimePrefix = "Cumulative duration msec:",
.lastEntrySupported = true,
.lastEntryPrefix = "Last entry timestamp msec:",
};
std::vector<std::pair<std::string, std::string>> airStateHeaders = {
std::make_pair("Active", "ACTIVE"),
std::make_pair("Sleep", "SLEEP"),
std::make_pair("Deep-Sleep", "DEEP SLEEP"),
std::make_pair("Suspend", "SUSPEND"),
std::make_pair("Off", "OFF"),
std::make_pair("Unknown", "UNKNOWN"),
};
sp<GenericStateResidencyDataProvider> airSdp =
new GenericStateResidencyDataProvider(
"/sys/devices/platform/soc/soc:abc-sm/state_stats");
uint32_t airId = service->addPowerEntity("Visual-Core", PowerEntityType::SUBSYSTEM);
airSdp->addEntity(airId, PowerEntityConfig("Pixel Visual Core Subsystem Power Stats",
generateGenericStateResidencyConfigs(airStateConfig, airStateHeaders)));
service->addStateResidencyDataProvider(airSdp);
// Add NFC power entity
StateResidencyConfig nfcStateConfig = {
.entryCountSupported = true,
.entryCountPrefix = "Cumulative count:",
.totalTimeSupported = true,
.totalTimePrefix = "Cumulative duration msec:",
.lastEntrySupported = true,
.lastEntryPrefix = "Last entry timestamp msec:"
};
std::vector<std::pair<std::string, std::string>> nfcStateHeaders = {
std::make_pair("Idle", "Idle mode:"),
std::make_pair("Active", "Active mode:"),
std::make_pair("Active-RW", "Active Reader/Writer mode:"),
};
sp<GenericStateResidencyDataProvider> nfcSdp =
new GenericStateResidencyDataProvider("/sys/class/misc/st21nfc/device/power_stats");
uint32_t nfcId = service->addPowerEntity("NFC", PowerEntityType::SUBSYSTEM);
nfcSdp->addEntity(nfcId,
PowerEntityConfig(generateGenericStateResidencyConfigs(nfcStateConfig, nfcStateHeaders)));
service->addStateResidencyDataProvider(nfcSdp);
// Add GPU power entity
uint32_t gpuId = service->addPowerEntity("GPU", PowerEntityType::SUBSYSTEM);
sp<GpuStateResidencyDataProvider> gpuSdp = new GpuStateResidencyDataProvider(gpuId);
service->addStateResidencyDataProvider(gpuSdp);
// Add Oslo power entity
uint32_t osloId = service->addPowerEntity("Oslo", PowerEntityType::SUBSYSTEM);
sp<OsloStateResidencyDataProvider> osloSdp = new OsloStateResidencyDataProvider(osloId);
service->addStateResidencyDataProvider(osloSdp);
// 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;
}