diff --git a/device.mk b/device.mk index d8055175..542abd98 100755 --- a/device.mk +++ b/device.mk @@ -345,8 +345,7 @@ PRODUCT_PACKAGES += \ # Thermal packages PRODUCT_PACKAGES += \ - android.hardware.thermal@1.0-impl \ - android.hardware.thermal@1.0-service + android.hardware.thermal@1.0-service.wahoo #GNSS HAL PRODUCT_PACKAGES += \ diff --git a/sepolicy/vendor/file_contexts b/sepolicy/vendor/file_contexts index 4475ed46..1f40f1c7 100644 --- a/sepolicy/vendor/file_contexts +++ b/sepolicy/vendor/file_contexts @@ -165,6 +165,7 @@ /vendor/bin/oemlock-bridge u:object_r:hal_bootctl_default_exec:s0 /vendor/bin/hw/android\.hardware\.usb@1\.1-service.wahoo u:object_r:hal_usb_default_exec:s0 /vendor/bin/hw/android\.hardware\.power@1\.1-service.wahoo u:object_r:hal_power_default_exec:s0 +/vendor/bin/hw/android\.hardware\.thermal@1\.0-service.wahoo u:object_r:hal_thermal_default_exec:s0 /vendor/bin/chre u:object_r:chre_exec:s0 /vendor/bin/time_daemon u:object_r:time_daemon_exec:s0 /vendor/bin/imsrcsd u:object_r:hal_rcsservice_exec:s0 diff --git a/thermal/Android.mk b/thermal/Android.mk new file mode 100644 index 00000000..a725c83e --- /dev/null +++ b/thermal/Android.mk @@ -0,0 +1,37 @@ +# +# Copyright 2017 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_PROPRIETARY_MODULE := true +LOCAL_MODULE_OWNER := qcom +LOCAL_MODULE_TAGS := optional + +LOCAL_MODULE := android.hardware.thermal@1.0-service.wahoo +LOCAL_INIT_RC := android.hardware.thermal@1.0-service.wahoo.rc +LOCAL_SRC_FILES := service.cpp Thermal.cpp thermal-helper.cpp + +LOCAL_SHARED_LIBRARIES := \ + libhidlbase \ + libhidltransport \ + libutils \ + libbase \ + android.hardware.thermal@1.0 \ + +include $(BUILD_EXECUTABLE) diff --git a/thermal/Thermal.cpp b/thermal/Thermal.cpp new file mode 100644 index 00000000..5bedddee --- /dev/null +++ b/thermal/Thermal.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2017 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 +#include + +#include + +#include "Thermal.h" +#include "thermal-helper.h" + +namespace android { +namespace hardware { +namespace thermal { +namespace V1_0 { +namespace implementation { + +Thermal::Thermal() : enabled(initThermal()) {} + +// Methods from ::android::hardware::thermal::V1_0::IThermal follow. +Return Thermal::getTemperatures(getTemperatures_cb _hidl_cb) { + ThermalStatus status; + status.code = ThermalStatusCode::SUCCESS; + hidl_vec temperatures; + temperatures.resize(kTemperatureNum); + + if (!enabled) { + status.code = ThermalStatusCode::FAILURE; + status.debugMessage = "Unsupported hardware"; + _hidl_cb(status, temperatures); + return Void(); + } + + ssize_t ret = fillTemperatures(&temperatures); + if (ret < 0) { + status.code = ThermalStatusCode::FAILURE; + status.debugMessage = strerror(-ret); + } + _hidl_cb(status, temperatures); + + for (auto& t : temperatures) { + LOG(DEBUG) << "getTemperatures " + << " Type: " << static_cast(t.type) + << " Name: " << t.name + << " CurrentValue: " << t.currentValue + << " ThrottlingThreshold: " << t.throttlingThreshold + << " ShutdownThreshold: " << t.shutdownThreshold + << " VrThrottlingThreshold: " << t.vrThrottlingThreshold; + } + + return Void(); +} + +Return Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) { + ThermalStatus status; + status.code = ThermalStatusCode::SUCCESS; + hidl_vec cpuUsages; + cpuUsages.resize(kCpuNum); + + if (!enabled) { + status.code = ThermalStatusCode::FAILURE; + status.debugMessage = "Unsupported hardware"; + _hidl_cb(status, cpuUsages); + return Void(); + } + + ssize_t ret = fillCpuUsages(&cpuUsages); + if (ret < 0) { + status.code = ThermalStatusCode::FAILURE; + status.debugMessage = strerror(-ret); + } + + for (auto& u : cpuUsages) { + LOG(DEBUG) << "getCpuUsages " + << " Name: " << u.name + << " Active: " << u.active + << " Total: " << u.total + << " IsOnline: " << u.isOnline; + } + + _hidl_cb(status, cpuUsages); + return Void(); +} + +Return Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) { + ThermalStatus status; + status.code = ThermalStatusCode::SUCCESS; + hidl_vec coolingDevices; + + if (!enabled) { + status.code = ThermalStatusCode::FAILURE; + status.debugMessage = "Unsupported hardware"; + _hidl_cb(status, coolingDevices); + return Void(); + } + + LOG(DEBUG) << "No Cooling Device"; + _hidl_cb(status, coolingDevices); + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace thermal +} // namespace hardware +} // namespace android diff --git a/thermal/Thermal.h b/thermal/Thermal.h new file mode 100644 index 00000000..f9ce7ed8 --- /dev/null +++ b/thermal/Thermal.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2017 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 ANDROID_HARDWARE_THERMAL_V1_0_WAHOO_THERMAL_H +#define ANDROID_HARDWARE_THERMAL_V1_0_WAHOO_THERMAL_H + +#include +#include +#include + +namespace android { +namespace hardware { +namespace thermal { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::thermal::V1_0::CoolingDevice; +using ::android::hardware::thermal::V1_0::CpuUsage; +using ::android::hardware::thermal::V1_0::IThermal; +using ::android::hardware::thermal::V1_0::Temperature; +using ::android::hardware::thermal::V1_0::ThermalStatus; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct Thermal : public IThermal { + Thermal(); + // Methods from ::android::hardware::thermal::V1_0::IThermal follow. + Return getTemperatures(getTemperatures_cb _hidl_cb) override; + Return getCpuUsages(getCpuUsages_cb _hidl_cb) override; + Return getCoolingDevices(getCoolingDevices_cb _hidl_cb) override; + + private: + bool enabled; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace thermal +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_THERMAL_V1_0_WAHOO_THERMAL_H diff --git a/thermal/android.hardware.thermal@1.0-service.wahoo.rc b/thermal/android.hardware.thermal@1.0-service.wahoo.rc new file mode 100644 index 00000000..e522cb10 --- /dev/null +++ b/thermal/android.hardware.thermal@1.0-service.wahoo.rc @@ -0,0 +1,4 @@ +service thermal-hal-1-0 /vendor/bin/hw/android.hardware.thermal@1.0-service.wahoo + class hal + user nobody + group nobody diff --git a/thermal/service.cpp b/thermal/service.cpp new file mode 100644 index 00000000..d41953b6 --- /dev/null +++ b/thermal/service.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2017 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 +#include +#include "Thermal.h" + +using android::sp; +using android::status_t; +using android::OK; + +// libhwbinder: +using android::hardware::configureRpcThreadpool; +using android::hardware::joinRpcThreadpool; + +// Generated HIDL files +using android::hardware::thermal::V1_0::IThermal; +using android::hardware::thermal::V1_0::implementation::Thermal; + +int main() { + + status_t status; + android::sp service = nullptr; + + LOG(INFO) << "Thermal HAL Service 1.0 is starting"; + + service = new Thermal(); + if (service == nullptr) { + LOG(ERROR) << "Can not create an instance of Thermal HAL Iface, exiting"; + + goto shutdown; + } + + configureRpcThreadpool(1, true /*callerWillJoin*/); + + status = service->registerAsService(); + if (status != OK) { + LOG(ERROR) << "Could not register service for Thermal HAL Iface (" << status << ")"; + goto shutdown; + } + + LOG(INFO) << "Thermal Service is ready"; + joinRpcThreadpool(); + // Should not pass this line + +shutdown: + // In normal operation, we don't expect the thread pool to exit + LOG(ERROR) << "Thermal Service is shutting down"; + return 1; +} diff --git a/thermal/thermal-helper.cpp b/thermal/thermal-helper.cpp new file mode 100644 index 00000000..f5f146cf --- /dev/null +++ b/thermal/thermal-helper.cpp @@ -0,0 +1,293 @@ +/* + * Copyright (C) 2017 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 +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "thermal-helper.h" + +namespace android { +namespace hardware { +namespace thermal { +namespace V1_0 { +namespace implementation { + +static unsigned int gSkinSensorNum; +static unsigned int gTsensOffset; +static unsigned int gSkinThrottlingThreshold; +static unsigned int gSkinShutdownThreshold; +static unsigned int gVrThrottledBelowMin; + +/** + * Initialization constants based on platform + * + * @return true on success or false on error. + */ +bool initThermal() { + std::string hardware = android::base::GetProperty("ro.hardware", ""); + if (hardware == "walleye") { + LOG(ERROR) << "Initialization on Walleye"; + gSkinSensorNum = kWalleyeSkinSensorNum; + gTsensOffset = kWalleyeTsensOffset; + gSkinThrottlingThreshold = kWalleyeSkinThrottlingThreshold; + gSkinShutdownThreshold = kWalleyeSkinShutdownThreshold; + gVrThrottledBelowMin = kWalleyeVrThrottledBelowMin; + } else if (hardware == "taimen") { + std::string rev = android::base::GetProperty("ro.revision", ""); + if (rev == "rev_a" || rev == "rev_b") { + LOG(ERROR) << "Initialization on Taimen pre revision C"; + gSkinSensorNum = kTaimenRabSkinSensorNum; + gTsensOffset = kTaimenRabTsensOffset; + gSkinThrottlingThreshold = kTaimenRabSkinThrottlingThreshold; + gSkinShutdownThreshold = kTaimenRabSkinShutdownThreshold; + gVrThrottledBelowMin = kTaimenRabVrThrottledBelowMin; + } else { + LOG(ERROR) << "Initialization on Taimen revision C and later"; + gSkinSensorNum = kTaimenRcSkinSensorNum; + gTsensOffset = kTaimenRcTsensOffset; + gSkinThrottlingThreshold = kTaimenRcSkinThrottlingThreshold; + gSkinShutdownThreshold = kTaimenRcSkinShutdownThreshold; + gVrThrottledBelowMin = kTaimenRcVrThrottledBelowMin; + } + } else { + LOG(ERROR) << "Unsupported hardware: " << hardware; + return false; + } + return true; +} + +/** + * Reads device temperature. + * + * @param sensor_num Number of sensor file with temperature. + * @param type Device temperature type. + * @param name Device temperature name. + * @param mult Multiplier used to translate temperature to Celsius. + * @param throttling_threshold Throttling threshold for the temperature. + * @param shutdown_threshold Shutdown threshold for the temperature. + * @param out Pointer to temperature_t structure that will be filled with current + * values. + * + * @return 0 on success or negative value -errno on error. + */ +static ssize_t readTemperature(int sensor_num, TemperatureType type, const char *name, float mult, + float throttling_threshold, float shutdown_threshold, + float vr_throttling_threshold, Temperature *out) { + FILE *file; + char file_name[PATH_MAX]; + float temp; + + sprintf(file_name, kTemperatureFileFormat, sensor_num); + file = fopen(file_name, "r"); + if (file == NULL) { + PLOG(ERROR) << "readTemperature: failed to open file (" << file_name << ")"; + return -errno; + } + if (1 != fscanf(file, "%f", &temp)) { + fclose(file); + PLOG(ERROR) << "readTemperature: failed to read a float"; + return errno ? -errno : -EIO; + } + + fclose(file); + + (*out).type = type; + (*out).name = name; + (*out).currentValue = temp * mult; + (*out).throttlingThreshold = throttling_threshold; + (*out).shutdownThreshold = shutdown_threshold; + (*out).vrThrottlingThreshold = vr_throttling_threshold; + + LOG(DEBUG) << android::base::StringPrintf( + "readTemperature: %d, %d, %s, %g, %g, %g, %g", + sensor_num, type, name, temp * mult, throttling_threshold, + shutdown_threshold, vr_throttling_threshold); + + return 0; +} + +static ssize_t getCpuTemperatures(hidl_vec *temperatures) { + size_t cpu; + + for (cpu = 0; cpu < kCpuNum; cpu++) { + if (cpu >= temperatures->size()) { + break; + } + // temperature in decidegrees Celsius. + ssize_t result = readTemperature(kCpuTsensOffset[cpu] + gTsensOffset, TemperatureType::CPU, kCpuLabel[cpu], + 0.1, kCpuThrottlingThreshold, kCpuShutdownThreshold, kCpuThrottlingThreshold, + &(*temperatures)[cpu]); + if (result != 0) { + return result; + } + } + return cpu; +} + +ssize_t fillTemperatures(hidl_vec *temperatures) { + ssize_t result = 0; + size_t current_index = 0; + + if (temperatures == NULL || temperatures->size() < kTemperatureNum) { + LOG(ERROR) << "fillTemperatures: incorrect buffer"; + return -EINVAL; + } + + result = getCpuTemperatures(temperatures); + if (result < 0) { + return result; + } + current_index += result; + + // GPU temperature. + if (current_index < temperatures->size()) { + // temperature in decidegrees Celsius. + result = readTemperature(gTsensOffset + kGpuTsensOffset, TemperatureType::GPU, kGpuLabel, 0.1, + NAN, NAN, NAN, &(*temperatures)[current_index]); + if (result < 0) { + return result; + } + current_index++; + } + + // Battery temperature. + if (current_index < temperatures->size()) { + // battery: temperature in millidegrees Celsius. + result = readTemperature(kBatterySensorNum, TemperatureType::BATTERY, kBatteryLabel, + 0.001, NAN, kBatteryShutdownThreshold, NAN, + &(*temperatures)[current_index]); + if (result < 0) { + return result; + } + current_index++; + } + + // Skin temperature. + if (current_index < temperatures->size()) { + // temperature in Celsius. + result = readTemperature(gSkinSensorNum, TemperatureType::SKIN, kSkinLabel, 1., + gSkinThrottlingThreshold, gSkinShutdownThreshold, gVrThrottledBelowMin, + &(*temperatures)[current_index]); + if (result < 0) { + return result; + } + current_index++; + } + return kTemperatureNum; +} + +ssize_t fillCpuUsages(hidl_vec *cpuUsages) { + int vals, cpu_num, online; + ssize_t read; + uint64_t user, nice, system, idle, active, total; + char *line = NULL; + size_t len = 0; + size_t size = 0; + char file_name[PATH_MAX]; + FILE *file; + FILE *cpu_file; + + if (cpuUsages == NULL || cpuUsages->size() < kCpuNum ) { + LOG(ERROR) << "fillCpuUsages: incorrect buffer"; + return -EINVAL; + } + + file = fopen(kCpuUsageFile, "r"); + if (file == NULL) { + PLOG(ERROR) << "fillCpuUsages: failed to open file (" << kCpuUsageFile << ")"; + return -errno; + } + + while ((read = getline(&line, &len, file)) != -1) { + // Skip non "cpu[0-9]" lines. + if (strnlen(line, read) < 4 || strncmp(line, "cpu", 3) != 0 || !isdigit(line[3])) { + free(line); + line = NULL; + len = 0; + continue; + } + + vals = sscanf(line, "cpu%d %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64, &cpu_num, &user, + &nice, &system, &idle); + + free(line); + line = NULL; + len = 0; + + if (vals != 5 || size == kCpuNum) { + if (vals != 5) { + PLOG(ERROR) << "fillCpuUsages: failed to read CPU information from file (" + << kCpuUsageFile << ")"; + } else { + PLOG(ERROR) << "fillCpuUsages: file has incorrect format (" + << kCpuUsageFile << ")"; + } + fclose(file); + return errno ? -errno : -EIO; + } + + active = user + nice + system; + total = active + idle; + + // Read online CPU information. + snprintf(file_name, PATH_MAX, kCpuOnlineFileFormat, cpu_num); + cpu_file = fopen(file_name, "r"); + online = 0; + if (cpu_file == NULL) { + PLOG(ERROR) << "fillCpuUsages: failed to open file (" << file_name << ")"; + fclose(file); + return -errno; + } + if (1 != fscanf(cpu_file, "%d", &online)) { + PLOG(ERROR) << "fillCpuUsages: failed to read CPU online information from file (" + << file_name << ")"; + fclose(file); + fclose(cpu_file); + return errno ? -errno : -EIO; + } + fclose(cpu_file); + + (*cpuUsages)[size].name = kCpuLabel[size]; + (*cpuUsages)[size].active = active; + (*cpuUsages)[size].total = total; + (*cpuUsages)[size].isOnline = static_cast(online); + + LOG(DEBUG) << "fillCpuUsages: "<< kCpuLabel[size] << ": " + << active << " " << total << " " << online; + size++; + } + fclose(file); + + if (size != kCpuNum) { + PLOG(ERROR) << "fillCpuUsages: file has incorrect format (" << kCpuUsageFile << ")"; + return -EIO; + } + return kCpuNum; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace thermal +} // namespace hardware +} // namespace android diff --git a/thermal/thermal-helper.h b/thermal/thermal-helper.h new file mode 100644 index 00000000..9d6eef22 --- /dev/null +++ b/thermal/thermal-helper.h @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __THERMAL_HELPER_H__ +#define __THERMAL_HELPER_H__ + +#include + +namespace android { +namespace hardware { +namespace thermal { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::thermal::V1_0::CpuUsage; +using ::android::hardware::thermal::V1_0::Temperature; + +constexpr const char *kCpuUsageFile = "/proc/stat"; +constexpr const char *kTemperatureFileFormat = "/sys/class/thermal/thermal_zone%d/temp"; +constexpr const char *kCpuOnlineFileFormat = "/sys/devices/system/cpu/cpu%d/online"; + +// thermal-engine.conf +constexpr unsigned int kWalleyeSkinSensorNum = 9; +constexpr unsigned int kWalleyeTsensOffset = 11; +constexpr unsigned int kWalleyeSkinThrottlingThreshold = 40; +constexpr unsigned int kWalleyeSkinShutdownThreshold = 56; +constexpr unsigned int kWalleyeVrThrottledBelowMin = 52; + +constexpr unsigned int kTaimenRabSkinSensorNum = 7; +constexpr unsigned int kTaimenRabTsensOffset = 8; +constexpr unsigned int kTaimenRabSkinThrottlingThreshold = 49; +constexpr unsigned int kTaimenRabSkinShutdownThreshold = 66; +constexpr unsigned int kTaimenRabVrThrottledBelowMin = 62; + +constexpr unsigned int kTaimenRcSkinSensorNum = 7; +constexpr unsigned int kTaimenRcTsensOffset = 8; +constexpr unsigned int kTaimenRcSkinThrottlingThreshold = 38; +constexpr unsigned int kTaimenRcSkinShutdownThreshold = 54; +constexpr unsigned int kTaimenRcVrThrottledBelowMin = 50; + + +constexpr unsigned int kBatterySensorNum = 0; +constexpr unsigned int kGpuTsensOffset = 11; +constexpr unsigned int kCpuNum = 8; + +constexpr const char *kGpuLabel = "GPU"; +constexpr const char *kBatteryLabel = "battery"; +constexpr const char *kSkinLabel = "skin"; +constexpr const char *kCpuLabel[kCpuNum] = {"CPU0", "CPU1", "CPU2", "CPU3", "CPU4", "CPU5", "CPU6", "CPU7"}; +constexpr int kCpuTsensOffset[kCpuNum] = {1, 2, 4, 3, 5, 6, 7, 8}; + +// Sum of kCpuNum + 3 for GPU, BATTERY, and SKIN. +constexpr unsigned int kTemperatureNum = 3 + kCpuNum; + +// qcom, therm-reset-temp +constexpr unsigned int kCpuShutdownThreshold = 115; +// qcom,freq-mitigation-temp +constexpr unsigned int kCpuThrottlingThreshold = 95; + +// config_shutdownBatteryTemperature in overlay/frameworks/base/core/res/res/values/config.xml +constexpr unsigned int kBatteryShutdownThreshold = 60; + + +bool initThermal(); +ssize_t fillTemperatures(hidl_vec *temperatures); +ssize_t fillCpuUsages(hidl_vec *cpuUsages); + +} // namespace implementation +} // namespace V1_0 +} // namespace thermal +} // namespace hardware +} // namespace android + +#endif //__THERMAL_HELPER_H__