diff options
Diffstat (limited to 'powerstats/service.cpp')
| -rw-r--r-- | powerstats/service.cpp | 792 |
1 files changed, 412 insertions, 380 deletions
diff --git a/powerstats/service.cpp b/powerstats/service.cpp index 4cf1f357..632de322 100644 --- a/powerstats/service.cpp +++ b/powerstats/service.cpp @@ -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" - -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::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) { +#include <dataproviders/DisplayStateResidencyDataProvider.h> +#include <dataproviders/GenericStateResidencyDataProvider.h> +#include <dataproviders/IioEnergyMeterDataProvider.h> +#include <dataproviders/PowerStatsEnergyConsumer.h> +#include <dataproviders/PowerStatsEnergyAttribution.h> +#include <dataproviders/PixelStateResidencyDataProvider.h> + +#include <android-base/logging.h> +#include <android-base/properties.h> +#include <android/binder_manager.h> +#include <android/binder_process.h> +#include <log/log.h> + +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; + +constexpr char kBootHwSoCRev[] = "ro.boot.hw.soc.rev"; + +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)); -} - -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, - }; - - 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); + p->addStateResidencyDataProvider( + std::make_shared<AocStateResidencyDataProvider>(monitorIds, monitorStates)); } -void addDvfsStats(PowerStats *const service) { - sp<DvfsStateResidencyDataProvider> dvfsSdp = new DvfsStateResidencyDataProvider( - "/sys/devices/platform/1742048c.acpm_stats/fvp_stats", NS_TO_MS); - - 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 addDvfsStats(std::shared_ptr<PowerStats> p) { + // A constant to represent the number of nanoseconds in one millisecond + const int NS_TO_MS = 1000000; + + 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 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 addSoC(std::shared_ptr<PowerStats> p) { + // A constant to represent the number of nanoseconds in one millisecond. + const int NS_TO_MS = 1000000; -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"); - - 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))); - - service->addStateResidencyDataProvider(socSdp); + 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:"); + + auto socSdp = std::make_shared<GenericStateResidencyDataProvider>( + "/sys/devices/platform/1742048c.acpm_stats/soc_stats", cfgs); + + 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 + + /* + * 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); +} - // The transform function converts microseconds to milliseconds. - std::function<uint64_t(uint64_t)> usecToMs = [](uint64_t a) { return a / 1000; }; - StateResidencyConfig stateConfig = { +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<GenericStateResidencyDataProvider::PowerEntityConfig> cfgs; + cfgs.emplace_back(generateGenericStateResidencyConfigs(powerStateConfig, powerStateHeaders), + "MODEM", ""); + + p->addStateResidencyDataProvider(std::make_shared<GenericStateResidencyDataProvider>( + "/sys/devices/platform/cpif/modem/power_stats", cfgs)); + + p->addEnergyConsumer(PowerStatsEnergyConsumer::createMeterConsumer(p, + EnergyConsumerType::MOBILE_RADIO, "MODEM", {"VSYS_PWR_MODEM", "VSYS_PWR_RFFE"})); +} + +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:", }; - 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<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:"), }; - wifiSdp->addEntity( - service->addPowerEntity("WIFI", PowerEntityType::SUBSYSTEM), - PowerEntityConfig(generateGenericStateResidencyConfigs(stateConfig, stateHeaders))); - wifiSdp->addEntity(service->addPowerEntity("WIFI-PCIE", PowerEntityType::SUBSYSTEM), - PowerEntityConfig(generateGenericStateResidencyConfigs(pcieStateConfig, - pcieStateHeaders))); + 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); - service->addStateResidencyDataProvider(wifiSdp); + p->addStateResidencyDataProvider(nfcSdp); } -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; - } +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:"), + }; - sp<android::ProcessState> ps{android::ProcessState::self()}; // Create non-HW binder threadpool - ps->startThreadPool(); + // 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); - // Configure the threadpool - configureRpcThreadpool(1, true /*callerWillJoin*/); + // 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); +} - status_t status = service->registerAsService(); - if (status != OK) { - ALOGE("Could not register service for power.stats HAL Iface (%d), exiting.", status); - return 1; - } +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); - ALOGI("power.stats service is ready"); - joinRpcThreadpool(); + 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); - // In normal operation, we don't expect the thread pool to exit - ALOGE("power.stats service is shutting down"); - return 1; + ABinderProcess_joinThreadPool(); + return EXIT_FAILURE; // should not reach } |