Remove power stats HAL 1.0 service
Bug: 179527556 Test: dumpsys android.hardware.power.stats.IPowerStats/default Test: device boot and examined logs to make sure no errors related to missing power stats 1.0 Change-Id: Ib8cc394f9968edaf948a2d9700e9f7fcaa5b9dc0
This commit is contained in:
Benjamin Schwartz
parent
d287e223f4
commit
0d6392efa6
19 changed files with 597 additions and 2078 deletions
|
|
@ -14,313 +14,174 @@
|
|||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "android.hardware.power.stats@1.0-service.gs101"
|
||||
|
||||
#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>
|
||||
#define LOG_TAG "android.hardware.power.stats-service.pixel"
|
||||
|
||||
#include <PowerStatsAidl.h>
|
||||
#include "AocStateResidencyDataProvider.h"
|
||||
#include "DvfsStateResidencyDataProvider.h"
|
||||
#include "RailDataProvider.h"
|
||||
#include "UfsStateResidencyDataProvider.h"
|
||||
#include <dataproviders/DisplayStateResidencyDataProvider.h>
|
||||
#include <dataproviders/GenericStateResidencyDataProvider.h>
|
||||
#include <dataproviders/IioEnergyMeterDataProvider.h>
|
||||
#include <dataproviders/PowerStatsEnergyConsumer.h>
|
||||
#include <dataproviders/PowerStatsEnergyAttribution.h>
|
||||
#include <dataproviders/PixelStateResidencyDataProvider.h>
|
||||
|
||||
using android::OK;
|
||||
using android::sp;
|
||||
using android::status_t;
|
||||
#include <android-base/logging.h>
|
||||
#include <android-base/properties.h>
|
||||
#include <android/binder_manager.h>
|
||||
#include <android/binder_process.h>
|
||||
#include <log/log.h>
|
||||
|
||||
// libhwbinder:
|
||||
using android::hardware::configureRpcThreadpool;
|
||||
using android::hardware::joinRpcThreadpool;
|
||||
using aidl::android::hardware::power::stats::AocStateResidencyDataProvider;
|
||||
using aidl::android::hardware::power::stats::DisplayStateResidencyDataProvider;
|
||||
using aidl::android::hardware::power::stats::DvfsStateResidencyDataProvider;
|
||||
using aidl::android::hardware::power::stats::EnergyConsumerType;
|
||||
using aidl::android::hardware::power::stats::GenericStateResidencyDataProvider;
|
||||
using aidl::android::hardware::power::stats::IioEnergyMeterDataProvider;
|
||||
using aidl::android::hardware::power::stats::PixelStateResidencyDataProvider;
|
||||
using aidl::android::hardware::power::stats::PowerStats;
|
||||
using aidl::android::hardware::power::stats::PowerStatsEnergyConsumer;
|
||||
|
||||
// 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;
|
||||
constexpr char kBootHwSoCRev[] = "ro.boot.hw.soc.rev";
|
||||
|
||||
// Pixel specific
|
||||
using android::hardware::google::pixel::powerstats::AidlStateResidencyDataProvider;
|
||||
using android::hardware::google::pixel::powerstats::AocStateResidencyDataProvider;
|
||||
using android::hardware::google::pixel::powerstats::DvfsStateResidencyDataProvider;
|
||||
using android::hardware::google::pixel::powerstats::generateGenericStateResidencyConfigs;
|
||||
using android::hardware::google::pixel::powerstats::GenericStateResidencyDataProvider;
|
||||
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::UfsStateResidencyDataProvider;
|
||||
|
||||
// A constant to represnt the number of nanoseconds in one millisecond.
|
||||
static const int NS_TO_MS = 1000000;
|
||||
|
||||
void addAoCStats(PowerStats *const service) {
|
||||
void addAoC(std::shared_ptr<PowerStats> p) {
|
||||
std::string prefix = "/sys/devices/platform/19000000.aoc/control/";
|
||||
|
||||
// Add AoC cores (a32, ff1, hf0, and hf1)
|
||||
std::vector<std::pair<uint32_t, std::string>> coreIds = {
|
||||
{service->addPowerEntity("AoC-A32", PowerEntityType::SUBSYSTEM), prefix + "a32_"},
|
||||
{service->addPowerEntity("AoC-FF1", PowerEntityType::SUBSYSTEM), prefix + "ff1_"},
|
||||
{service->addPowerEntity("AoC-HF1", PowerEntityType::SUBSYSTEM), prefix + "hf1_"},
|
||||
{service->addPowerEntity("AoC-HF0", PowerEntityType::SUBSYSTEM), prefix + "hf0_"},
|
||||
std::vector<std::pair<std::string, std::string>> coreIds = {
|
||||
{"AoC-A32", prefix + "a32_"},
|
||||
{"AoC-FF1", prefix + "ff1_"},
|
||||
{"AoC-HF1", prefix + "hf1_"},
|
||||
{"AoC-HF0", prefix + "hf0_"},
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> coreStates = {
|
||||
{"DWN", "off"}, {"RET", "retention"}, {"WFI", "wfi"}};
|
||||
service->addStateResidencyDataProvider(new AocStateResidencyDataProvider(coreIds, coreStates));
|
||||
p->addStateResidencyDataProvider(std::make_shared<AocStateResidencyDataProvider>(coreIds,
|
||||
coreStates));
|
||||
|
||||
// Add AoC voltage stats
|
||||
std::vector<std::pair<uint32_t, std::string>> voltageIds = {
|
||||
{service->addPowerEntity("AoC-Voltage", PowerEntityType::SUBSYSTEM),
|
||||
prefix + "voltage_"},
|
||||
std::vector<std::pair<std::string, std::string>> voltageIds = {
|
||||
{"AoC-Voltage", prefix + "voltage_"},
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> voltageStates = {{"NOM", "nominal"},
|
||||
{"SUD", "super_underdrive"},
|
||||
{"UUD", "ultra_underdrive"},
|
||||
{"UD", "underdrive"}};
|
||||
service->addStateResidencyDataProvider(
|
||||
new AocStateResidencyDataProvider(voltageIds, voltageStates));
|
||||
p->addStateResidencyDataProvider(
|
||||
std::make_shared<AocStateResidencyDataProvider>(voltageIds, voltageStates));
|
||||
|
||||
// Add AoC monitor mode
|
||||
std::vector<std::pair<uint32_t, std::string>> monitorIds = {
|
||||
{service->addPowerEntity("AoC", PowerEntityType::SUBSYSTEM), prefix + "monitor_"},
|
||||
std::vector<std::pair<std::string, std::string>> monitorIds = {
|
||||
{"AoC", prefix + "monitor_"},
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> monitorStates = {
|
||||
{"MON", "mode"},
|
||||
};
|
||||
service->addStateResidencyDataProvider(
|
||||
new AocStateResidencyDataProvider(monitorIds, monitorStates));
|
||||
p->addStateResidencyDataProvider(
|
||||
std::make_shared<AocStateResidencyDataProvider>(monitorIds, monitorStates));
|
||||
}
|
||||
|
||||
void addCpuCStateStats(PowerStats *const service) {
|
||||
// CPU stats are reported in nanoseconds. The transform function
|
||||
// converts nanoseconds to milliseconds.
|
||||
std::function<uint64_t(uint64_t)> cpuNsToMs = [](uint64_t a) { return a / NS_TO_MS; };
|
||||
StateResidencyConfig cStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "down_count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "total_down_time_ns:",
|
||||
.totalTimeTransform = cpuNsToMs,
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "last_down_time_ns:",
|
||||
.lastEntryTransform = cpuNsToMs,
|
||||
};
|
||||
void addDvfsStats(std::shared_ptr<PowerStats> p) {
|
||||
// A constant to represent the number of nanoseconds in one millisecond
|
||||
const int NS_TO_MS = 1000000;
|
||||
|
||||
sp<GenericStateResidencyDataProvider> cStateSdp = new GenericStateResidencyDataProvider(
|
||||
"/sys/devices/platform/1742048c.acpm_stats/core_stats");
|
||||
for (std::string state :
|
||||
{"CORE00", "CORE01", "CORE02", "CORE03", "CORE10", "CORE11", "CORE20", "CORE21"}) {
|
||||
cStateSdp->addEntity(service->addPowerEntity(state, PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("CORES:", generateGenericStateResidencyConfigs(
|
||||
cStateConfig,
|
||||
{std::make_pair("DOWN", state)})));
|
||||
}
|
||||
for (std::string state : {"CLUSTER0", "CLUSTER1", "CLUSTER2"}) {
|
||||
cStateSdp->addEntity(
|
||||
service->addPowerEntity(state, PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("CLUSTERS:",
|
||||
generateGenericStateResidencyConfigs(
|
||||
cStateConfig, {std::make_pair("DOWN", state)})));
|
||||
}
|
||||
service->addStateResidencyDataProvider(cStateSdp);
|
||||
std::vector<DvfsStateResidencyDataProvider::Config> cfgs;
|
||||
|
||||
cfgs.push_back({"MIF", {
|
||||
std::make_pair("3172KHz", "3172000"),
|
||||
std::make_pair("2730KHz", "2730000"),
|
||||
std::make_pair("2535KHz", "2535000"),
|
||||
std::make_pair("2288KHz", "2288000"),
|
||||
std::make_pair("2028KHz", "2028000"),
|
||||
std::make_pair("1716KHz", "1716000"),
|
||||
std::make_pair("1539KHz", "1539000"),
|
||||
std::make_pair("1352KHz", "1352000"),
|
||||
std::make_pair("1014KHz", "1014000"),
|
||||
std::make_pair("845KHz", "845000"),
|
||||
std::make_pair("676KHz", "676000"),
|
||||
std::make_pair("546KHz", "546000"),
|
||||
std::make_pair("421KHz", "421000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
}});
|
||||
|
||||
cfgs.push_back({"CL0", {
|
||||
std::make_pair("2024KHz", "2024000"),
|
||||
std::make_pair("1950KHz", "1950000"),
|
||||
std::make_pair("1868KHz", "1868000"),
|
||||
std::make_pair("1803KHz", "1803000"),
|
||||
std::make_pair("1745KHz", "1745000"),
|
||||
std::make_pair("1704KHz", "1704000"),
|
||||
std::make_pair("1598KHz", "1598000"),
|
||||
std::make_pair("1459KHz", "1459000"),
|
||||
std::make_pair("1401KHz", "1401000"),
|
||||
std::make_pair("1328KHz", "1328000"),
|
||||
std::make_pair("1197KHz", "1197000"),
|
||||
std::make_pair("1098KHz", "1098000"),
|
||||
std::make_pair("930KHz", "930000"),
|
||||
std::make_pair("889KHz", "889000"),
|
||||
std::make_pair("738KHz", "738000"),
|
||||
std::make_pair("574KHz", "574000"),
|
||||
std::make_pair("300KHz", "300000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
}});
|
||||
|
||||
cfgs.push_back({"CL1", {
|
||||
std::make_pair("2253KHz", "2253000"),
|
||||
std::make_pair("2130KHz", "2130000"),
|
||||
std::make_pair("1999KHz", "1999000"),
|
||||
std::make_pair("1836KHz", "1836000"),
|
||||
std::make_pair("1663KHz", "1663000"),
|
||||
std::make_pair("1491KHz", "1491000"),
|
||||
std::make_pair("1328KHz", "1328000"),
|
||||
std::make_pair("1197KHz", "1197000"),
|
||||
std::make_pair("1024KHz", "1024000"),
|
||||
std::make_pair("910KHz", "910000"),
|
||||
std::make_pair("799KHz", "799000"),
|
||||
std::make_pair("696KHz", "696000"),
|
||||
std::make_pair("533KHz", "533000"),
|
||||
std::make_pair("400KHz", "400000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
}});
|
||||
|
||||
cfgs.push_back({"CL2", {
|
||||
std::make_pair("2630KHz", "2630000"),
|
||||
std::make_pair("2507KHz", "2507000"),
|
||||
std::make_pair("2401KHz", "2401000"),
|
||||
std::make_pair("2302KHz", "2302000"),
|
||||
std::make_pair("2252KHz", "2252000"),
|
||||
std::make_pair("2188KHz", "2188000"),
|
||||
std::make_pair("2048KHz", "2048000"),
|
||||
std::make_pair("1901KHz", "1901000"),
|
||||
std::make_pair("1826KHz", "1826000"),
|
||||
std::make_pair("1745KHz", "1745000"),
|
||||
std::make_pair("1582KHz", "1582000"),
|
||||
std::make_pair("1426KHz", "1426000"),
|
||||
std::make_pair("1277KHz", "1277000"),
|
||||
std::make_pair("1237KHz", "1237000"),
|
||||
std::make_pair("1106KHz", "1106000"),
|
||||
std::make_pair("984KHz", "984000"),
|
||||
std::make_pair("851KHz", "851000"),
|
||||
std::make_pair("848KHz", "848000"),
|
||||
std::make_pair("500KHz", "500000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
}});
|
||||
|
||||
cfgs.push_back({"TPU", {
|
||||
std::make_pair("1066MHz", "1066000000"),
|
||||
}});
|
||||
|
||||
p->addStateResidencyDataProvider(std::make_shared<DvfsStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/1742048c.acpm_stats/fvp_stats", NS_TO_MS, cfgs));
|
||||
}
|
||||
|
||||
void addDvfsStats(PowerStats *const service) {
|
||||
sp<DvfsStateResidencyDataProvider> dvfsSdp = new DvfsStateResidencyDataProvider(
|
||||
"/sys/devices/platform/1742048c.acpm_stats/fvp_stats", NS_TO_MS);
|
||||
void addSoC(std::shared_ptr<PowerStats> p) {
|
||||
// A constant to represent the number of nanoseconds in one millisecond.
|
||||
const int NS_TO_MS = 1000000;
|
||||
|
||||
dvfsSdp->addEntity(service->addPowerEntity("MIF-DVFS", PowerEntityType::SUBSYSTEM), "MIF",
|
||||
{
|
||||
std::make_pair("3172KHz", "3172000"),
|
||||
std::make_pair("2730KHz", "2730000"),
|
||||
std::make_pair("2535KHz", "2535000"),
|
||||
std::make_pair("2288KHz", "2288000"),
|
||||
std::make_pair("2028KHz", "2028000"),
|
||||
std::make_pair("1716KHz", "1716000"),
|
||||
std::make_pair("1539KHz", "1539000"),
|
||||
std::make_pair("1352KHz", "1352000"),
|
||||
std::make_pair("1014KHz", "1014000"),
|
||||
std::make_pair("845KHz", "845000"),
|
||||
std::make_pair("676KHz", "676000"),
|
||||
std::make_pair("546KHz", "546000"),
|
||||
std::make_pair("421KHz", "421000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
});
|
||||
|
||||
dvfsSdp->addEntity(service->addPowerEntity("CL0-DVFS", PowerEntityType::SUBSYSTEM), "CL0",
|
||||
{
|
||||
std::make_pair("2196KHz", "2196000"),
|
||||
std::make_pair("2098KHz", "2098000"),
|
||||
std::make_pair("2024KHz", "2024000"),
|
||||
std::make_pair("1950KHz", "1950000"),
|
||||
std::make_pair("1868KHz", "1868000"),
|
||||
std::make_pair("1745KHz", "1745000"),
|
||||
std::make_pair("1598KHz", "1598000"),
|
||||
std::make_pair("1459KHz", "1459000"),
|
||||
std::make_pair("1328KHz", "1328000"),
|
||||
std::make_pair("1197KHz", "1197000"),
|
||||
std::make_pair("1098KHz", "1098000"),
|
||||
std::make_pair("889KHz", "889000"),
|
||||
std::make_pair("738KHz", "738000"),
|
||||
std::make_pair("574KHz", "574000"),
|
||||
std::make_pair("300KHz", "300000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
});
|
||||
|
||||
dvfsSdp->addEntity(service->addPowerEntity("CL1-DVFS", PowerEntityType::SUBSYSTEM), "CL1",
|
||||
{
|
||||
std::make_pair("2466KHz", "2466000"),
|
||||
std::make_pair("2393KHz", "2393000"),
|
||||
std::make_pair("2348KHz", "2348000"),
|
||||
std::make_pair("2253KHz", "2253000"),
|
||||
std::make_pair("2130KHz", "2130000"),
|
||||
std::make_pair("1999KHz", "1999000"),
|
||||
std::make_pair("1836KHz", "1836000"),
|
||||
std::make_pair("1663KHz", "1663000"),
|
||||
std::make_pair("1491KHz", "1491000"),
|
||||
std::make_pair("1328KHz", "1328000"),
|
||||
std::make_pair("1197KHz", "1197000"),
|
||||
std::make_pair("1024KHz", "1024000"),
|
||||
std::make_pair("910KHz", "910000"),
|
||||
std::make_pair("799KHz", "799000"),
|
||||
std::make_pair("696KHz", "696000"),
|
||||
std::make_pair("533KHz", "533000"),
|
||||
std::make_pair("400KHz", "400000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
});
|
||||
|
||||
dvfsSdp->addEntity(service->addPowerEntity("CL2-DVFS", PowerEntityType::SUBSYSTEM), "CL2",
|
||||
{
|
||||
std::make_pair("3195KHz", "3195000"),
|
||||
std::make_pair("3097KHz", "3097000"),
|
||||
std::make_pair("2999KHz", "2999000"),
|
||||
std::make_pair("2900KHz", "2900000"),
|
||||
std::make_pair("2802KHz", "2802000"),
|
||||
std::make_pair("2704KHz", "2704000"),
|
||||
std::make_pair("2630KHz", "2630000"),
|
||||
std::make_pair("2507KHz", "2507000"),
|
||||
std::make_pair("2401KHz", "2401000"),
|
||||
std::make_pair("2302KHz", "2302000"),
|
||||
std::make_pair("2188KHz", "2188000"),
|
||||
std::make_pair("2048KHz", "2048000"),
|
||||
std::make_pair("1901KHz", "1901000"),
|
||||
std::make_pair("1745KHz", "1745000"),
|
||||
std::make_pair("1582KHz", "1582000"),
|
||||
std::make_pair("1426KHz", "1426000"),
|
||||
std::make_pair("1237KHz", "1237000"),
|
||||
std::make_pair("1106KHz", "1106000"),
|
||||
std::make_pair("984KHz", "984000"),
|
||||
std::make_pair("848KHz", "848000"),
|
||||
std::make_pair("500KHz", "500000"),
|
||||
std::make_pair("0KHz", "0"),
|
||||
});
|
||||
|
||||
// TODO(sujee): Complete frequency table for TPU.
|
||||
dvfsSdp->addEntity(service->addPowerEntity("TPU-DVFS", PowerEntityType::SUBSYSTEM), "TPU",
|
||||
{
|
||||
std::make_pair("1066MHz", "1066000000"),
|
||||
});
|
||||
|
||||
service->addStateResidencyDataProvider(dvfsSdp);
|
||||
}
|
||||
|
||||
void addGPUStats(PowerStats *const service) {
|
||||
StateResidencyConfig gpuStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "count = ",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "total_time = ",
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "last_entry_time = ",
|
||||
};
|
||||
|
||||
sp<GenericStateResidencyDataProvider> gpu = new GenericStateResidencyDataProvider(
|
||||
"/sys/devices/platform/1c500000.mali/power_stats");
|
||||
|
||||
PowerEntityConfig onOffConfig("Summary stats: (times in ms)",
|
||||
generateGenericStateResidencyConfigs(
|
||||
gpuStateConfig, {{"DOWN", "OFF:"}, {"UP", "ON:"}}));
|
||||
gpu->addEntity(service->addPowerEntity("GPU", PowerEntityType::SUBSYSTEM), onOffConfig);
|
||||
|
||||
PowerEntityConfig DVFSConfig(
|
||||
"DVFS stats: (times in ms)",
|
||||
generateGenericStateResidencyConfigs(gpuStateConfig, {{"996MHz", "996000:"},
|
||||
{"885MHz", "885000:"},
|
||||
{"750MHz", "750000:"},
|
||||
{"434MHz", "434000:"},
|
||||
{"302MHz", "302000:"},
|
||||
{"151MHz", "151000:"}}));
|
||||
gpu->addEntity(service->addPowerEntity("GPU-DVFS", PowerEntityType::SUBSYSTEM), DVFSConfig);
|
||||
service->addStateResidencyDataProvider(gpu);
|
||||
}
|
||||
|
||||
void addNFCStats(PowerStats *const service) {
|
||||
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/devices/platform/10960000.hsi2c/i2c-4/4-0008/power_stats");
|
||||
nfcSdp->addEntity(service->addPowerEntity("NFC", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("NFC subsystem", generateGenericStateResidencyConfigs(
|
||||
nfcStateConfig, nfcStateHeaders)));
|
||||
service->addStateResidencyDataProvider(nfcSdp);
|
||||
}
|
||||
|
||||
void addPCIeStats(PowerStats *const service) {
|
||||
// Add PCIe power entities for Modem and WiFi
|
||||
StateResidencyConfig pcieStateConfig = {
|
||||
.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>> pcieStateHeaders = {
|
||||
std::make_pair("UP", "Link up:"),
|
||||
std::make_pair("DOWN", "Link down:"),
|
||||
};
|
||||
|
||||
// Add PCIe - Modem
|
||||
sp<GenericStateResidencyDataProvider> pcieModemSdp = new GenericStateResidencyDataProvider(
|
||||
"/sys/devices/platform/11920000.pcie/power_stats");
|
||||
uint32_t pcieModemId = service->addPowerEntity("PCIe-Modem", PowerEntityType::SUBSYSTEM);
|
||||
pcieModemSdp->addEntity(
|
||||
pcieModemId,
|
||||
PowerEntityConfig("Version: 1", generateGenericStateResidencyConfigs(
|
||||
pcieStateConfig, pcieStateHeaders)));
|
||||
service->addStateResidencyDataProvider(pcieModemSdp);
|
||||
|
||||
// Add PCIe - WiFi
|
||||
sp<GenericStateResidencyDataProvider> pcieWifiSdp = new GenericStateResidencyDataProvider(
|
||||
"/sys/devices/platform/14520000.pcie/power_stats");
|
||||
uint32_t pcieWifiId = service->addPowerEntity("PCIe-WiFi", PowerEntityType::SUBSYSTEM);
|
||||
pcieWifiSdp->addEntity(
|
||||
pcieWifiId,
|
||||
PowerEntityConfig("Version: 1", generateGenericStateResidencyConfigs(
|
||||
pcieStateConfig, pcieStateHeaders)));
|
||||
service->addStateResidencyDataProvider(pcieWifiSdp);
|
||||
}
|
||||
|
||||
void addSocStats(PowerStats *const service) {
|
||||
// ACPM stats are reported in nanoseconds. The transform function
|
||||
// converts nanoseconds to milliseconds.
|
||||
std::function<uint64_t(uint64_t)> acpmNsToMs = [](uint64_t a) { return a / NS_TO_MS; };
|
||||
StateResidencyConfig lpmStateConfig = {
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig lpmStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "success_count:",
|
||||
.totalTimeSupported = true,
|
||||
|
|
@ -330,7 +191,7 @@ void addSocStats(PowerStats *const service) {
|
|||
.lastEntryPrefix = "last_entry_time_ns:",
|
||||
.lastEntryTransform = acpmNsToMs,
|
||||
};
|
||||
StateResidencyConfig downStateConfig = {
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig downStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "down_count:",
|
||||
.totalTimeSupported = true,
|
||||
|
|
@ -340,7 +201,7 @@ void addSocStats(PowerStats *const service) {
|
|||
.lastEntryPrefix = "last_down_time_ns:",
|
||||
.lastEntryTransform = acpmNsToMs,
|
||||
};
|
||||
StateResidencyConfig reqStateConfig = {
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig reqStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "req_up_count:",
|
||||
.totalTimeSupported = true,
|
||||
|
|
@ -351,141 +212,312 @@ void addSocStats(PowerStats *const service) {
|
|||
.lastEntryTransform = acpmNsToMs,
|
||||
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> powerStateHeaders = {
|
||||
const std::vector<std::pair<std::string, std::string>> powerStateHeaders = {
|
||||
std::make_pair("SICD", "SICD"),
|
||||
std::make_pair("SLEEP", "SLEEP"),
|
||||
std::make_pair("SLEEP_SLCMON", "SLEEP_SLCMON"),
|
||||
std::make_pair("STOP", "STOP"),
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> mifReqStateHeaders = {
|
||||
const std::vector<std::pair<std::string, std::string>> mifReqStateHeaders = {
|
||||
std::make_pair("AOC", "AOC"),
|
||||
std::make_pair("GSA", "GSA"),
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> slcReqStateHeaders = {
|
||||
const std::vector<std::pair<std::string, std::string>> slcReqStateHeaders = {
|
||||
std::make_pair("AOC", "AOC"),
|
||||
};
|
||||
|
||||
sp<GenericStateResidencyDataProvider> socSdp = new GenericStateResidencyDataProvider(
|
||||
"/sys/devices/platform/1742048c.acpm_stats/soc_stats");
|
||||
std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> cfgs;
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(lpmStateConfig, powerStateHeaders),
|
||||
"LPM", "LPM:");
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(downStateConfig, powerStateHeaders),
|
||||
"MIF", "MIF:");
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(reqStateConfig, mifReqStateHeaders),
|
||||
"MIF-REQ", "MIF_REQ:");
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(downStateConfig, powerStateHeaders),
|
||||
"SLC", "SLC:");
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(reqStateConfig, slcReqStateHeaders),
|
||||
"SLC-REQ", "SLC_REQ:");
|
||||
|
||||
socSdp->addEntity(service->addPowerEntity("LPM", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("LPM:", generateGenericStateResidencyConfigs(
|
||||
lpmStateConfig, powerStateHeaders)));
|
||||
socSdp->addEntity(service->addPowerEntity("MIF", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("MIF:", generateGenericStateResidencyConfigs(
|
||||
downStateConfig, powerStateHeaders)));
|
||||
socSdp->addEntity(service->addPowerEntity("MIF-REQ", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("MIF_REQ:", generateGenericStateResidencyConfigs(
|
||||
reqStateConfig, mifReqStateHeaders)));
|
||||
socSdp->addEntity(service->addPowerEntity("SLC", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("SLC:", generateGenericStateResidencyConfigs(
|
||||
downStateConfig, powerStateHeaders)));
|
||||
socSdp->addEntity(service->addPowerEntity("SLC-REQ", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig("SLC_REQ:", generateGenericStateResidencyConfigs(
|
||||
reqStateConfig, slcReqStateHeaders)));
|
||||
auto socSdp = std::make_shared<GenericStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/1742048c.acpm_stats/soc_stats", cfgs);
|
||||
|
||||
service->addStateResidencyDataProvider(socSdp);
|
||||
p->addStateResidencyDataProvider(socSdp);
|
||||
}
|
||||
|
||||
void addUfsStats(PowerStats *const service) {
|
||||
sp<UfsStateResidencyDataProvider> ufsSdp = new UfsStateResidencyDataProvider(
|
||||
service->addPowerEntity("UFS", PowerEntityType::SUBSYSTEM));
|
||||
service->addStateResidencyDataProvider(ufsSdp);
|
||||
void setEnergyMeter(std::shared_ptr<PowerStats> p) {
|
||||
std::vector<const std::string> deviceNames { "s2mpg10-odpm", "s2mpg11-odpm" };
|
||||
p->setEnergyMeterDataProvider(std::make_unique<IioEnergyMeterDataProvider>(deviceNames, true));
|
||||
}
|
||||
|
||||
void addWifiStats(PowerStats *const service) {
|
||||
sp<GenericStateResidencyDataProvider> wifiSdp =
|
||||
new GenericStateResidencyDataProvider("/sys/wifi/power_stats");
|
||||
void addDisplay(std::shared_ptr<PowerStats> p) {
|
||||
// Add display residency stats
|
||||
|
||||
// The transform function converts microseconds to milliseconds.
|
||||
std::function<uint64_t(uint64_t)> usecToMs = [](uint64_t a) { return a / 1000; };
|
||||
StateResidencyConfig stateConfig = {
|
||||
/*
|
||||
* TODO(b/167216667): Add complete set of display states here. Must account
|
||||
* for ALL devices built using this source
|
||||
*/
|
||||
std::vector<std::string> states = {
|
||||
"Off",
|
||||
"LP: 1440x3040@30",
|
||||
"On: 1440x3040@60",
|
||||
"On: 1440x3040@90",
|
||||
"HBM: 1440x3040@60",
|
||||
"HBM: 1440x3040@90"};
|
||||
|
||||
auto displaySdp =
|
||||
std::make_shared<DisplayStateResidencyDataProvider>("Display",
|
||||
"/sys/class/backlight/panel0-backlight/state",
|
||||
states);
|
||||
p->addStateResidencyDataProvider(displaySdp);
|
||||
|
||||
// Add display energy consumer
|
||||
/*
|
||||
* TODO(b/167216667): Add correct display power model here. Must read from display rail
|
||||
* and include proper coefficients for display states. Must account for ALL devices built
|
||||
* using this source.
|
||||
*/
|
||||
auto displayConsumer = PowerStatsEnergyConsumer::createMeterAndEntityConsumer(p,
|
||||
EnergyConsumerType::DISPLAY, "display", {"PPVAR_VSYS_PWR_DISP"}, "Display",
|
||||
{{"LP: 1440x3040@30", 1},
|
||||
{"On: 1440x3040@60", 2},
|
||||
{"On: 1440x3040@90", 3}});
|
||||
|
||||
p->addEnergyConsumer(displayConsumer);
|
||||
}
|
||||
|
||||
void addCPUclusters(std::shared_ptr<PowerStats> p) {
|
||||
p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p,
|
||||
EnergyConsumerType::CPU_CLUSTER, "CPUCL0", {"S4M_VDD_CPUCL0"}));
|
||||
p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p,
|
||||
EnergyConsumerType::CPU_CLUSTER, "CPUCL1", {"S3M_VDD_CPUCL1"}));
|
||||
p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p,
|
||||
EnergyConsumerType::CPU_CLUSTER, "CPUCL2", {"S2M_VDD_CPUCL2"}));
|
||||
}
|
||||
|
||||
void addGPU(std::shared_ptr<PowerStats> p) {
|
||||
// Add gpu energy consumer
|
||||
std::map<std::string, int32_t> stateCoeffs;
|
||||
const int socRev = android::base::GetIntProperty(kBootHwSoCRev, 0);
|
||||
|
||||
// B0/B1 chips have different GPU DVFS operating points than A0/A1 SoC
|
||||
if (socRev >= 2) {
|
||||
stateCoeffs = {
|
||||
{"151000", 10},
|
||||
{"202000", 20},
|
||||
{"251000", 30},
|
||||
{"302000", 40},
|
||||
{"351000", 50},
|
||||
{"400000", 60},
|
||||
{"471000", 70},
|
||||
{"510000", 80},
|
||||
{"572000", 90},
|
||||
{"701000", 100},
|
||||
{"762000", 110},
|
||||
{"848000", 120}};
|
||||
} else {
|
||||
stateCoeffs = {
|
||||
{"151000", 10},
|
||||
{"302000", 20},
|
||||
{"455000", 30},
|
||||
{"572000", 40},
|
||||
{"670000", 50}};
|
||||
}
|
||||
|
||||
auto gpuConsumer = PowerStatsEnergyConsumer::createMeterAndAttrConsumer(p,
|
||||
EnergyConsumerType::OTHER, "GPU", {"S2S_VDD_G3D"},
|
||||
{{UID_TIME_IN_STATE, "/sys/devices/platform/1c500000.mali/uid_time_in_state"}},
|
||||
stateCoeffs);
|
||||
|
||||
p->addEnergyConsumer(gpuConsumer);
|
||||
}
|
||||
|
||||
void addMobileRadio(std::shared_ptr<PowerStats> p)
|
||||
{
|
||||
// A constant to represent the number of microseconds in one millisecond.
|
||||
const int US_TO_MS = 1000;
|
||||
|
||||
// modem power_stats are reported in microseconds. The transform function
|
||||
// converts microseconds to milliseconds.
|
||||
std::function<uint64_t(uint64_t)> modemUsToMs = [](uint64_t a) { return a / US_TO_MS; };
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig powerStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "duration_usec:",
|
||||
.totalTimeTransform = usecToMs,
|
||||
.totalTimeTransform = modemUsToMs,
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "last_entry_timestamp_usec:",
|
||||
.lastEntryTransform = usecToMs,
|
||||
.lastEntryTransform = modemUsToMs,
|
||||
};
|
||||
StateResidencyConfig pcieStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "duration_usec:",
|
||||
.totalTimeTransform = usecToMs,
|
||||
const std::vector<std::pair<std::string, std::string>> powerStateHeaders = {
|
||||
std::make_pair("SLEEP", "SLEEP:"),
|
||||
};
|
||||
|
||||
std::vector<std::pair<std::string, std::string>> stateHeaders = {
|
||||
std::make_pair("AWAKE", "AWAKE:"),
|
||||
std::make_pair("ASLEEP", "ASLEEP:"),
|
||||
};
|
||||
std::vector<std::pair<std::string, std::string>> pcieStateHeaders = {
|
||||
std::make_pair("L0", "L0:"), std::make_pair("L1", "L1:"),
|
||||
std::make_pair("L1_1", "L1_1:"), std::make_pair("L1_2", "L1_2:"),
|
||||
std::make_pair("L2", "L2:"),
|
||||
};
|
||||
std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> cfgs;
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(powerStateConfig, powerStateHeaders),
|
||||
"MODEM", "");
|
||||
|
||||
wifiSdp->addEntity(
|
||||
service->addPowerEntity("WIFI", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig(generateGenericStateResidencyConfigs(stateConfig, stateHeaders)));
|
||||
wifiSdp->addEntity(service->addPowerEntity("WIFI-PCIE", PowerEntityType::SUBSYSTEM),
|
||||
PowerEntityConfig(generateGenericStateResidencyConfigs(pcieStateConfig,
|
||||
pcieStateHeaders)));
|
||||
p->addStateResidencyDataProvider(std::make_shared<GenericStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/cpif/modem/power_stats", cfgs));
|
||||
|
||||
service->addStateResidencyDataProvider(wifiSdp);
|
||||
p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p,
|
||||
EnergyConsumerType::MOBILE_RADIO, "MODEM", {"VSYS_PWR_MODEM", "VSYS_PWR_RFFE"}));
|
||||
}
|
||||
|
||||
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>());
|
||||
|
||||
addAoCStats(service);
|
||||
addCpuCStateStats(service);
|
||||
addDvfsStats(service);
|
||||
addGPUStats(service);
|
||||
addNFCStats(service);
|
||||
addPCIeStats(service);
|
||||
addSocStats(service);
|
||||
addUfsStats(service);
|
||||
addWifiStats(service);
|
||||
|
||||
// Add Power Entities that require the Aidl data provider
|
||||
sp<AidlStateResidencyDataProvider> aidlSdp = new AidlStateResidencyDataProvider();
|
||||
uint32_t bluetoothId = service->addPowerEntity("Bluetooth", PowerEntityType::SUBSYSTEM);
|
||||
aidlSdp->addEntity(bluetoothId, "Bluetooth", {"Idle", "Active", "Tx", "Rx"});
|
||||
uint32_t citadelId = service->addPowerEntity("Citadel", PowerEntityType::SUBSYSTEM);
|
||||
aidlSdp->addEntity(citadelId, "Citadel", {"Last-Reset", "Active", "Deep-Sleep"});
|
||||
service->addStateResidencyDataProvider(aidlSdp);
|
||||
|
||||
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();
|
||||
|
||||
// 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;
|
||||
void addGNSS(std::shared_ptr<PowerStats> p)
|
||||
{
|
||||
p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p,
|
||||
EnergyConsumerType::GNSS, "GPS", {"L9S_GNSS_CORE"}));
|
||||
}
|
||||
|
||||
void addNFC(std::shared_ptr<PowerStats> p) {
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig nfcStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "Cumulative count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "Cumulative duration msec:",
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "Last entry timestamp msec:",
|
||||
};
|
||||
const 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:"),
|
||||
};
|
||||
|
||||
std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> cfgs;
|
||||
cfgs.emplace_back(generateGenericStateResidencyConfigs(nfcStateConfig, nfcStateHeaders),
|
||||
"NFC", "NFC subsystem");
|
||||
|
||||
auto nfcSdp = std::make_shared<GenericStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/10960000.hsi2c/i2c-3/3-0008/power_stats", cfgs);
|
||||
|
||||
p->addStateResidencyDataProvider(nfcSdp);
|
||||
}
|
||||
|
||||
void addPCIe(std::shared_ptr<PowerStats> p) {
|
||||
// Add PCIe power entities for Modem and WiFi
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig pcieStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "Cumulative count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "Cumulative duration msec:",
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "Last entry timestamp msec:",
|
||||
};
|
||||
const std::vector<std::pair<std::string, std::string>> pcieStateHeaders = {
|
||||
std::make_pair("UP", "Link up:"),
|
||||
std::make_pair("DOWN", "Link down:"),
|
||||
};
|
||||
|
||||
// Add PCIe - Modem
|
||||
const std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> pcieModemCfgs = {
|
||||
{generateGenericStateResidencyConfigs(pcieStateConfig, pcieStateHeaders), "PCIe-Modem",
|
||||
"Version: 1"}
|
||||
};
|
||||
auto pcieModemSdp = std::make_shared<GenericStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/11920000.pcie/power_stats", pcieModemCfgs);
|
||||
p->addStateResidencyDataProvider(pcieModemSdp);
|
||||
|
||||
// Add PCIe - WiFi
|
||||
const std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> pcieWifiCfgs = {
|
||||
{generateGenericStateResidencyConfigs(pcieStateConfig, pcieStateHeaders),
|
||||
"PCIe-WiFi", "Version: 1"}
|
||||
};
|
||||
auto pcieWifiSdp = std::make_shared<GenericStateResidencyDataProvider>(
|
||||
"/sys/devices/platform/14520000.pcie/power_stats", pcieWifiCfgs);
|
||||
p->addStateResidencyDataProvider(pcieWifiSdp);
|
||||
}
|
||||
|
||||
void addWifi(std::shared_ptr<PowerStats> p) {
|
||||
// The transform function converts microseconds to milliseconds.
|
||||
std::function<uint64_t(uint64_t)> usecToMs = [](uint64_t a) { return a / 1000; };
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig stateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "duration_usec:",
|
||||
.totalTimeTransform = usecToMs,
|
||||
.lastEntrySupported = true,
|
||||
.lastEntryPrefix = "last_entry_timestamp_usec:",
|
||||
.lastEntryTransform = usecToMs,
|
||||
};
|
||||
const GenericStateResidencyDataProvider::StateResidencyConfig pcieStateConfig = {
|
||||
.entryCountSupported = true,
|
||||
.entryCountPrefix = "count:",
|
||||
.totalTimeSupported = true,
|
||||
.totalTimePrefix = "duration_usec:",
|
||||
.totalTimeTransform = usecToMs,
|
||||
.lastEntrySupported = false,
|
||||
};
|
||||
|
||||
const std::vector<std::pair<std::string, std::string>> stateHeaders = {
|
||||
std::make_pair("AWAKE", "AWAKE:"),
|
||||
std::make_pair("ASLEEP", "ASLEEP:"),
|
||||
|
||||
};
|
||||
const std::vector<std::pair<std::string, std::string>> pcieStateHeaders = {
|
||||
std::make_pair("L0", "L0:"),
|
||||
std::make_pair("L1", "L1:"),
|
||||
std::make_pair("L1_1", "L1_1:"),
|
||||
std::make_pair("L1_2", "L1_2:"),
|
||||
std::make_pair("L2", "L2:"),
|
||||
};
|
||||
|
||||
const std::vector<GenericStateResidencyDataProvider::PowerEntityConfig> cfgs = {
|
||||
{generateGenericStateResidencyConfigs(stateConfig, stateHeaders), "WIFI", "WIFI"},
|
||||
{generateGenericStateResidencyConfigs(pcieStateConfig, pcieStateHeaders), "WIFI-PCIE",
|
||||
"WIFI-PCIE"}
|
||||
};
|
||||
|
||||
auto wifiSdp = std::make_shared<GenericStateResidencyDataProvider>("/sys/wifi/power_stats",
|
||||
cfgs);
|
||||
p->addStateResidencyDataProvider(wifiSdp);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unlike other data providers, which source power entity state residency data from the kernel,
|
||||
* this data provider acts as a general-purpose channel for state residency data providers
|
||||
* that live in user space. Entities are defined here and user space clients of this provider's
|
||||
* vendor service register callbacks to provide state residency data for their given pwoer entity.
|
||||
*/
|
||||
void addPixelStateResidencyDataProvider(std::shared_ptr<PowerStats> p) {
|
||||
std::shared_ptr<PixelStateResidencyDataProvider> pixelSdp =
|
||||
ndk::SharedRefBase::make<PixelStateResidencyDataProvider>();
|
||||
|
||||
pixelSdp->addEntity("Bluetooth", {{0, "Idle"}, {1, "Active"}, {2, "Tx"}, {3, "Rx"}});
|
||||
|
||||
pixelSdp->start();
|
||||
p->addStateResidencyDataProvider(pixelSdp);
|
||||
}
|
||||
|
||||
int main() {
|
||||
LOG(INFO) << "Pixel PowerStats HAL AIDL Service is starting.";
|
||||
|
||||
// single thread
|
||||
ABinderProcess_setThreadPoolMaxThreadCount(0);
|
||||
|
||||
std::shared_ptr<PowerStats> p = ndk::SharedRefBase::make<PowerStats>();
|
||||
|
||||
setEnergyMeter(p);
|
||||
|
||||
addPixelStateResidencyDataProvider(p);
|
||||
addAoC(p);
|
||||
addDisplay(p);
|
||||
addDvfsStats(p);
|
||||
addSoC(p);
|
||||
addCPUclusters(p);
|
||||
addGPU(p);
|
||||
addMobileRadio(p);
|
||||
addGNSS(p);
|
||||
addNFC(p);
|
||||
addPCIe(p);
|
||||
addWifi(p);
|
||||
|
||||
const std::string instance = std::string() + PowerStats::descriptor + "/default";
|
||||
binder_status_t status = AServiceManager_addService(p->asBinder().get(), instance.c_str());
|
||||
LOG_ALWAYS_FATAL_IF(status != STATUS_OK);
|
||||
|
||||
ABinderProcess_joinThreadPool();
|
||||
return EXIT_FAILURE; // should not reach
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue