1 /*
2  * Copyright (C) 2021 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "pixelstats-uevent: ChargeStatsReporter"
18 
19 #include <android-base/file.h>
20 #include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>
21 #include <log/log.h>
22 #include <pixelstats/ChargeStatsReporter.h>
23 #include <pixelstats/StatsHelper.h>
24 #include <time.h>
25 #include <utils/Timers.h>
26 
27 #include <cmath>
28 
29 namespace android {
30 namespace hardware {
31 namespace google {
32 namespace pixel {
33 
34 using aidl::android::frameworks::stats::IStats;
35 using aidl::android::frameworks::stats::VendorAtom;
36 using aidl::android::frameworks::stats::VendorAtomValue;
37 using android::base::ReadFileToString;
38 using android::base::WriteStringToFile;
39 using android::hardware::google::pixel::PixelAtoms::ChargeStats;
40 using android::hardware::google::pixel::PixelAtoms::VoltageTierStats;
41 
42 #define DURATION_FILTER_SECS 15
43 #define CHG_STATS_FMT "%d,%d,%d, %d,%d,%d,%d %d %d,%d, %d,%d"
44 
ChargeStatsReporter()45 ChargeStatsReporter::ChargeStatsReporter() {}
46 
getTimeSecs(void)47 int64_t ChargeStatsReporter::getTimeSecs(void) {
48     return nanoseconds_to_seconds(systemTime(SYSTEM_TIME_BOOTTIME));
49 }
50 
ReportChargeStats(const std::shared_ptr<IStats> & stats_client,const std::string line,const std::string wline_at,const std::string wline_ac,const std::string pca_line)51 void ChargeStatsReporter::ReportChargeStats(const std::shared_ptr<IStats> &stats_client,
52                                             const std::string line, const std::string wline_at,
53                                             const std::string wline_ac,
54                                             const std::string pca_line) {
55     int charge_stats_fields[] = {
56             ChargeStats::kAdapterTypeFieldNumber,
57             ChargeStats::kAdapterVoltageFieldNumber,
58             ChargeStats::kAdapterAmperageFieldNumber,
59             ChargeStats::kSsocInFieldNumber,
60             ChargeStats::kVoltageInFieldNumber,
61             ChargeStats::kSsocOutFieldNumber,
62             ChargeStats::kVoltageOutFieldNumber,
63             ChargeStats::kChargeCapacityFieldNumber,
64             ChargeStats::kCsiAggregateStatusFieldNumber,
65             ChargeStats::kCsiAggregateTypeFieldNumber,
66             ChargeStats::kAdapterCapabilities0FieldNumber,
67             ChargeStats::kAdapterCapabilities1FieldNumber,
68             ChargeStats::kAdapterCapabilities2FieldNumber,
69             ChargeStats::kAdapterCapabilities3FieldNumber,
70             ChargeStats::kAdapterCapabilities4FieldNumber,
71             ChargeStats::kReceiverState0FieldNumber,
72             ChargeStats::kReceiverState1FieldNumber,
73             ChargeStats::kAacrAlgoFieldNumber,
74             ChargeStats::kAacpVersionFieldNumber,
75             ChargeStats::kAaccFieldNumber,
76     };
77     const int32_t chg_fields_size = std::size(charge_stats_fields);
78     static_assert(chg_fields_size == 20, "Unexpected charge stats fields size");
79     const int32_t wlc_fields_size = 7;
80     std::vector<VendorAtomValue> values(chg_fields_size);
81     VendorAtomValue val;
82     int32_t i = 0, tmp[chg_fields_size] = {0};
83     int32_t pca_ac[2] = {0}, pca_rs[5] = {0}, stats_size;
84     std::string pdo_line, file_contents;
85     std::istringstream ss;
86 
87     ALOGD("processing %s", line.c_str());
88 
89     stats_size = sscanf(line.c_str(), CHG_STATS_FMT, &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4],
90                         &tmp[5], &tmp[6], &tmp[7], &tmp[8], &tmp[9], &tmp[18], &tmp[19]);
91     if (stats_size != kNumChgStatsFormat00Fields && stats_size != kNumChgStatsFormat01Fields &&
92         stats_size != kNumChgStatsFormat02Fields && stats_size != kNumChgStatsFormat03Fields) {
93         ALOGE("Couldn't process %s (stats_size: %d)", line.c_str(), stats_size);
94         return;
95     }
96 
97     if (!wline_at.empty()) {
98         int32_t ssoc_tmp = 0;
99         ALOGD("wlc: processing %s", wline_at.c_str());
100         if (sscanf(wline_at.c_str(), "A:%d", &ssoc_tmp) != 1) {
101             ALOGE("Couldn't process %s", wline_at.c_str());
102         } else {
103             tmp[0] = wireless_charge_stats_.TranslateSysModeToAtomValue(ssoc_tmp);
104             ALOGD("wlc: processing %s", wline_ac.c_str());
105             if (sscanf(wline_ac.c_str(), "D:%x,%x,%x,%x,%x, %x,%x", &tmp[10], &tmp[11], &tmp[12],
106                        &tmp[13], &tmp[14], &tmp[15], &tmp[16]) != 7)
107                 ALOGE("Couldn't process %s", wline_ac.c_str());
108         }
109     }
110 
111     if (!pca_line.empty()) {
112         ALOGD("pca: processing %s", pca_line.c_str());
113         if (sscanf(pca_line.c_str(), "D:%x,%x %x,%x,%x,%x,%x", &pca_ac[0], &pca_ac[1], &pca_rs[0],
114                    &pca_rs[1], &pca_rs[2], &pca_rs[3], &pca_rs[4]) != 7) {
115             ALOGE("Couldn't process %s", pca_line.c_str());
116         } else {
117             tmp[12] = pca_rs[2];
118             tmp[13] = pca_rs[3];
119             tmp[14] = pca_rs[4];
120             tmp[16] = pca_rs[1];
121             if (wline_at.empty()) {
122                 /* force adapter type to PPS when pca log is available, but not wlc */
123                 tmp[0] = PixelAtoms::ChargeStats::ADAPTER_TYPE_USB_PD_PPS;
124                 tmp[10] = pca_ac[0];
125                 tmp[11] = pca_ac[1];
126                 tmp[15] = pca_rs[0];
127             }
128         }
129     }
130 
131     if (ReadFileToString(kGChargerMetricsPath.c_str(), &file_contents)) {
132         ss.str(file_contents);
133         while (std::getline(ss, pdo_line)) {
134             if (sscanf(pdo_line.c_str(), "D:%x,%x,%x,%x,%x,%x,%x", &pca_ac[0], &pca_ac[1],
135                        &pca_rs[0], &pca_rs[1], &pca_rs[2], &pca_rs[3], &pca_rs[4]) != 7) {
136                 continue;
137             } else {
138                 ALOGD("processed %s, apdo:%d, pdo:%d", pdo_line.c_str(), pca_ac[1], pca_rs[4]);
139                 tmp[15] = pca_ac[1]; /* APDO */
140                 tmp[16] = pca_rs[4]; /* PDO */
141                 break;
142             }
143         }
144     }
145 
146     if (ReadFileToString(kGAacrAlgoPath.c_str(), &file_contents)) {
147         ss.str(file_contents);
148         ss >> tmp[17];
149     }
150 
151     for (i = 0; i < chg_fields_size; i++) {
152         val.set<VendorAtomValue::intValue>(tmp[i]);
153         values[charge_stats_fields[i] - kVendorAtomOffset] = val;
154     }
155 
156     VendorAtom event = {.reverseDomainName = "",
157                         .atomId = PixelAtoms::Atom::kChargeStats,
158                         .values = std::move(values)};
159     const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event);
160     if (!ret.isOk())
161         ALOGE("Unable to report ChargeStats to Stats service");
162 }
163 
ReportVoltageTierStats(const std::shared_ptr<IStats> & stats_client,const char * line,const bool has_wireless=false,const std::string & wfile_contents="")164 void ChargeStatsReporter::ReportVoltageTierStats(const std::shared_ptr<IStats> &stats_client,
165                                                  const char *line, const bool has_wireless = false,
166                                                  const std::string &wfile_contents = "") {
167     int voltage_tier_stats_fields[] = {
168             VoltageTierStats::kVoltageTierFieldNumber,
169             VoltageTierStats::kSocInFieldNumber, /* retrieved via ssoc_tmp */
170             VoltageTierStats::kCcInFieldNumber,
171             VoltageTierStats::kTempInFieldNumber,
172             VoltageTierStats::kTimeFastSecsFieldNumber,
173             VoltageTierStats::kTimeTaperSecsFieldNumber,
174             VoltageTierStats::kTimeOtherSecsFieldNumber,
175             VoltageTierStats::kTempMinFieldNumber,
176             VoltageTierStats::kTempAvgFieldNumber,
177             VoltageTierStats::kTempMaxFieldNumber,
178             VoltageTierStats::kIbattMinFieldNumber,
179             VoltageTierStats::kIbattAvgFieldNumber,
180             VoltageTierStats::kIbattMaxFieldNumber,
181             VoltageTierStats::kIclMinFieldNumber,
182             VoltageTierStats::kIclAvgFieldNumber,
183             VoltageTierStats::kIclMaxFieldNumber,
184             VoltageTierStats::kMinAdapterPowerOutFieldNumber,
185             VoltageTierStats::kTimeAvgAdapterPowerOutFieldNumber,
186             VoltageTierStats::kMaxAdapterPowerOutFieldNumber,
187             VoltageTierStats::kChargingOperatingPointFieldNumber};
188 
189     const int32_t vtier_fields_size = std::size(voltage_tier_stats_fields);
190     static_assert(vtier_fields_size == 20, "Unexpected voltage tier stats fields size");
191     const int32_t wlc_fields_size = 4;
192     std::vector<VendorAtomValue> values(vtier_fields_size);
193     VendorAtomValue val;
194     float ssoc_tmp;
195     int32_t i = 0, tmp[vtier_fields_size - 1] = {0}, /* ssoc_tmp is not saved in this array */
196             fields_size = (vtier_fields_size - wlc_fields_size);
197 
198     if (sscanf(line, "%d, %f,%d,%d, %d,%d,%d, %d,%d,%d, %d,%d,%d, %d,%d,%d", &tmp[0], &ssoc_tmp,
199                &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5], &tmp[6], &tmp[7], &tmp[8], &tmp[9],
200                &tmp[10], &tmp[11], &tmp[12], &tmp[13], &tmp[14]) != 16) {
201         /* If format isn't as expected, then ignore line on purpose */
202         return;
203     }
204 
205     if (has_wireless) {
206         wireless_charge_stats_.CalculateWirelessChargeStats(static_cast<int>(ssoc_tmp),
207                                                             wfile_contents);
208         tmp[15] = wireless_charge_stats_.pout_min_;
209         tmp[16] = wireless_charge_stats_.pout_avg_;
210         tmp[17] = wireless_charge_stats_.pout_max_;
211         tmp[18] = wireless_charge_stats_.of_freq_;
212         fields_size = vtier_fields_size; /* include wlc stats */
213     }
214 
215     ALOGD("VoltageTierStats: processed %s", line);
216     val.set<VendorAtomValue::intValue>(tmp[0]);
217     values[voltage_tier_stats_fields[0] - kVendorAtomOffset] = val;
218     val.set<VendorAtomValue::floatValue>(ssoc_tmp);
219     values[voltage_tier_stats_fields[1] - kVendorAtomOffset] = val;
220     for (i = 2; i < fields_size; i++) {
221         val.set<VendorAtomValue::intValue>(tmp[i - 1]);
222         values[voltage_tier_stats_fields[i] - kVendorAtomOffset] = val;
223     }
224 
225     VendorAtom event = {.reverseDomainName = "",
226                         .atomId = PixelAtoms::Atom::kVoltageTierStats,
227                         .values = std::move(values)};
228     const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event);
229     if (!ret.isOk())
230         ALOGE("Unable to report VoltageTierStats to Stats service");
231 }
232 
233 /**
234  * b/223664185
235  * Adds a rolling window filter to charge stats. If the time has expired, there will be a new log
236  * event.
237  *
238  * This helps ensure that we throttle stats even if there is an intermittent disconnect, while still
239  * retaining some stats on the disconnect.
240  */
shouldReportEvent(void)241 bool ChargeStatsReporter::shouldReportEvent(void) {
242     const int64_t current_time = getTimeSecs();
243     if (current_time == 0) {
244         ALOGE("Current boot time is zero!");
245         return false;
246     }
247 
248     if (log_event_time_secs_ == 0 || log_event_time_secs_ + DURATION_FILTER_SECS < current_time) {
249         log_event_time_secs_ = current_time;
250         return true;
251     }
252 
253     return false;
254 }
255 
checkAndReport(const std::shared_ptr<IStats> & stats_client,const std::string & path)256 void ChargeStatsReporter::checkAndReport(const std::shared_ptr<IStats> &stats_client,
257                                          const std::string &path) {
258     std::string file_contents, line, wfile_contents, wline_at, wline_ac, pca_file_contents,
259             pca_line, thermal_file_contents, gcharger_file_contents, gdbatt_file_contents;
260     std::istringstream ss;
261     bool has_wireless, has_pca, has_thermal, has_gcharger, has_dual_batt;
262 
263     if (!ReadFileToString(path.c_str(), &file_contents)) {
264         ALOGE("Unable to read %s - %s", path.c_str(), strerror(errno));
265         return;
266     }
267 
268     ss.str(file_contents);
269 
270     if (!std::getline(ss, line)) {
271         ALOGE("Unable to read first line");
272         return;
273     }
274 
275     if (!WriteStringToFile("0", path.c_str())) {
276         ALOGE("Couldn't clear %s - %s", path.c_str(), strerror(errno));
277     }
278 
279     if (!shouldReportEvent()) {
280         ALOGW("Too many log events; event ignored.");
281         return;
282     }
283 
284     has_pca = pca_charge_stats_.CheckPcaContentsAndAck(&pca_file_contents);
285     if (has_pca) {
286         std::istringstream pca_ss;
287 
288         pca_ss.str(pca_file_contents);
289         std::getline(pca_ss, pca_line);
290     }
291 
292     has_wireless = wireless_charge_stats_.CheckWirelessContentsAndAck(&wfile_contents);
293     if (has_wireless) {
294         std::istringstream wss;
295 
296         /* there are two lines in the head, A: ...(Adapter Type) and D: ...(Adapter Capabilities) */
297         wss.str(wfile_contents);
298         std::getline(wss, wline_at);
299         std::getline(wss, wline_ac);
300 
301         /* reset initial tier soc */
302         wireless_charge_stats_.tier_soc_ = 0;
303     }
304 
305     ReportChargeStats(stats_client, line, wline_at, wline_ac, pca_line);
306 
307     while (std::getline(ss, line)) {
308         ReportVoltageTierStats(stats_client, line.c_str(), has_wireless, wfile_contents);
309     }
310 
311     has_thermal = checkContentsAndAck(&thermal_file_contents, kThermalChargeMetricsPath);
312     if (has_thermal) {
313         std::istringstream wss;
314         wss.str(thermal_file_contents);
315         while (std::getline(wss, line)) {
316             ReportVoltageTierStats(stats_client, line.c_str());
317         }
318     }
319 
320     has_gcharger = checkContentsAndAck(&gcharger_file_contents, kGChargerMetricsPath);
321     if (has_gcharger) {
322         std::istringstream wss;
323         wss.str(gcharger_file_contents);
324         while (std::getline(wss, line)) {
325             ReportVoltageTierStats(stats_client, line.c_str());
326         }
327     }
328 
329     has_dual_batt = checkContentsAndAck(&gdbatt_file_contents, kGDualBattMetricsPath);
330     if (has_dual_batt) {
331         std::istringstream wss;
332         wss.str(gdbatt_file_contents);
333         while (std::getline(wss, line)) {
334             ReportVoltageTierStats(stats_client, line.c_str());
335         }
336     }
337 }
338 
checkContentsAndAck(std::string * file_contents,const std::string & path)339 bool ChargeStatsReporter::checkContentsAndAck(std::string *file_contents, const std::string &path) {
340     if (!ReadFileToString(path.c_str(), file_contents)) {
341         return false;
342     }
343 
344     if (!WriteStringToFile("0", path.c_str())) {
345         ALOGE("Couldn't clear %s - %s", path.c_str(), strerror(errno));
346         return false;
347     }
348     return true;
349 }
350 
351 }  // namespace pixel
352 }  // namespace google
353 }  // namespace hardware
354 }  // namespace android
355