thermal/thermal-helper.cpp - device/google/wahoo - Git at Google

 /*
  * 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 <cctype>
 #include <cerrno>
 #include <cinttypes>
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
 #include <tuple>
 #include <unordered_map>
 #include <vector>

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android-base/strings.h>
 #include <android-base/stringprintf.h>

 #include "sensors.h"
 #include "thermal-helper.h"

 namespace android {
 namespace hardware {
 namespace thermal {
 namespace V1_1 {
 namespace implementation {

 constexpr const char kThermalSensorsRoot[] = "/sys/class/thermal";
 constexpr char kThermalZoneDirSuffix[] = "thermal_zone";
 constexpr char kSensorTypeFileSuffix[] = "type";
 constexpr char kTemperatureFileSuffix[] = "temp";
 // This is a golden set of thermal sensor names, their types, and their
 // multiplier. Used when we read in sensor values. The tuple value stored is
 // formatted as such:
 // <temperature type, multiplier value for reading temp>
 const std::unordered_map<std::string, std::tuple<TemperatureType, float>>
 kValidThermalSensorsMap = {
     {"tsens_tz_sensor1", {TemperatureType::CPU, 0.1}},   // CPU0
     {"tsens_tz_sensor2", {TemperatureType::CPU, 0.1}},   // CPU1
     {"tsens_tz_sensor4", {TemperatureType::CPU, 0.1}},   // CPU2
     {"tsens_tz_sensor3", {TemperatureType::CPU, 0.1}},   // CPU3
     {"tsens_tz_sensor7", {TemperatureType::CPU, 0.1}},   // CPU4
     {"tsens_tz_sensor8", {TemperatureType::CPU, 0.1}},   // CPU5
     {"tsens_tz_sensor9", {TemperatureType::CPU, 0.1}},   // CPU6
     {"tsens_tz_sensor10", {TemperatureType::CPU, 0.1}},  // CPU7
     // GPU thermal sensor.
     {"tsens_tz_sensor13", {TemperatureType::GPU, 0.1}},
     // Battery thermal sensor.
     {"battery", {TemperatureType::BATTERY, 0.001}},
     // Skin thermal sensors. We use back_therm for walleye. For taimen we use
     // bd_therm and bd_therm2.
     {"back_therm", {TemperatureType::SKIN, 1.}},
     {"bd_therm", {TemperatureType::SKIN, 1.}},
     {"bd_therm2", {TemperatureType::SKIN, 1.}},
     // USBC thermal sensor.
     {"usb_port_temp", {TemperatureType::UNKNOWN, 0.1}},
 };

 namespace {

 using ::android::hardware::thermal::V1_0::TemperatureType;

 static std::string gSkinSensorType;
 static unsigned int gSkinThrottlingThreshold;
 static unsigned int gSkinShutdownThreshold;
 static unsigned int gVrThrottledBelowMin;
 Sensors gSensors;

 // A map containing hardcoded thresholds per sensor type.  Its not const
 // because initThermal() will modify the skin sensor thresholds depending on the
 // hardware type. The tuple is formatted as follows:
 // <throttling threshold, shutdown threshold, vr threshold>
 std::unordered_map<TemperatureType, std::tuple<float, float, float>>
 gSensorTypeToThresholdsMap = {
     {TemperatureType::CPU, {kCpuThrottlingThreshold, kCpuShutdownThreshold,
                              kCpuThrottlingThreshold}},
     {TemperatureType::GPU, {NAN, NAN, NAN}},
     {TemperatureType::BATTERY, {NAN, kBatteryShutdownThreshold, NAN}},
     {TemperatureType::SKIN, {NAN, NAN, NAN}},
     {TemperatureType::UNKNOWN, {NAN, NAN, NAN}}
 };

 bool initializeSensors() {
     auto thermal_zone_dir = std::unique_ptr<DIR, int (*)(DIR*)>(
         opendir(kThermalSensorsRoot), closedir);
     struct dirent* dp;
     size_t num_thermal_zones = 0;
     while ((dp = readdir(thermal_zone_dir.get())) != nullptr) {
         std::string dir_name(dp->d_name);
         if (dir_name.find(kThermalZoneDirSuffix) != std::string::npos) {
             ++num_thermal_zones;
         }
     }

     for (size_t sensor_zone_num = 0; sensor_zone_num < num_thermal_zones;
             ++sensor_zone_num) {
         std::string path = android::base::StringPrintf("%s/%s%zu",
                                                        kThermalSensorsRoot,
                                                        kThermalZoneDirSuffix,
                                                        sensor_zone_num);
         std::string sensor_name;
         if (android::base::ReadFileToString(
                 path + "/" + kSensorTypeFileSuffix, &sensor_name)) {
             sensor_name = android::base::Trim(sensor_name);
             if (kValidThermalSensorsMap.find(sensor_name) !=
                 kValidThermalSensorsMap.end()) {
                   TemperatureType type = std::get<0>(
                       kValidThermalSensorsMap.at(sensor_name));
                   auto thresholds = gSensorTypeToThresholdsMap.at(type);
                   if (!gSensors.addSensor(
                           sensor_name, path + "/" + kTemperatureFileSuffix,
                           std::get<0>(thresholds), std::get<1>(thresholds),
                           std::get<2>(thresholds), type)) {
                         LOG(ERROR) << "Could not add " << sensor_name
                                    << "to sensors map";
                   }
             }
         }
     }
     return (gSensors.getNumSensors() == kTemperatureNum);
 }

 }  // namespace

 /**
  * 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";
         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";
             gSkinThrottlingThreshold = kTaimenRabSkinThrottlingThreshold;
             gSkinShutdownThreshold = kTaimenRabSkinShutdownThreshold;
             gVrThrottledBelowMin = kTaimenRabVrThrottledBelowMin;
         } else {
             LOG(ERROR) << "Initialization on Taimen revision C and later";
             gSkinThrottlingThreshold = kTaimenRcSkinThrottlingThreshold;
             gSkinShutdownThreshold = kTaimenRcSkinShutdownThreshold;
             gVrThrottledBelowMin = kTaimenRcVrThrottledBelowMin;
         }
     } else {
         LOG(ERROR) << "Unsupported hardware: " << hardware;
         return false;
     }
     gSensorTypeToThresholdsMap[TemperatureType::SKIN] =
         std::make_tuple(gSkinThrottlingThreshold, gSkinShutdownThreshold,
                         gVrThrottledBelowMin);
     return initializeSensors();
 }

 ssize_t fillTemperatures(hidl_vec<Temperature>* temperatures) {
     temperatures->resize(gSensors.getNumSensors());
     ssize_t current_index = 0;
     for (const auto& name_type_mult_pair : kValidThermalSensorsMap) {
         Temperature temp;
         if (gSensors.readTemperature(name_type_mult_pair.first,
                                      std::get<1>(name_type_mult_pair.second),
                                      &temp)) {
             (*temperatures)[current_index] = temp;
             ++current_index;
         }
     }
     return current_index;
 }

 ssize_t fillCpuUsages(hidl_vec<CpuUsage> *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<bool>(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;
 }

 std::string getTargetSkinSensorType() {
     return gSkinSensorType;
 }

 }  // namespace implementation
 }  // namespace V1_1
 }  // namespace thermal
 }  // namespace hardware
 }  // namespace android
	/*
	* 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 <cctype>
	#include <cerrno>
	#include <cinttypes>
	#include <cmath>
	#include <cstdlib>
	#include <cstring>
	#include <tuple>
	#include <unordered_map>
	#include <vector>

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android-base/strings.h>
	#include <android-base/stringprintf.h>

	#include "sensors.h"
	#include "thermal-helper.h"

	namespace android {
	namespace hardware {
	namespace thermal {
	namespace V1_1 {
	namespace implementation {

	constexpr const char kThermalSensorsRoot[] = "/sys/class/thermal";
	constexpr char kThermalZoneDirSuffix[] = "thermal_zone";
	constexpr char kSensorTypeFileSuffix[] = "type";
	constexpr char kTemperatureFileSuffix[] = "temp";
	// This is a golden set of thermal sensor names, their types, and their
	// multiplier. Used when we read in sensor values. The tuple value stored is
	// formatted as such:
	// <temperature type, multiplier value for reading temp>
	const std::unordered_map<std::string, std::tuple<TemperatureType, float>>
	kValidThermalSensorsMap = {
	{"tsens_tz_sensor1", {TemperatureType::CPU, 0.1}}, // CPU0
	{"tsens_tz_sensor2", {TemperatureType::CPU, 0.1}}, // CPU1
	{"tsens_tz_sensor4", {TemperatureType::CPU, 0.1}}, // CPU2
	{"tsens_tz_sensor3", {TemperatureType::CPU, 0.1}}, // CPU3
	{"tsens_tz_sensor7", {TemperatureType::CPU, 0.1}}, // CPU4
	{"tsens_tz_sensor8", {TemperatureType::CPU, 0.1}}, // CPU5
	{"tsens_tz_sensor9", {TemperatureType::CPU, 0.1}}, // CPU6
	{"tsens_tz_sensor10", {TemperatureType::CPU, 0.1}}, // CPU7
	// GPU thermal sensor.
	{"tsens_tz_sensor13", {TemperatureType::GPU, 0.1}},
	// Battery thermal sensor.
	{"battery", {TemperatureType::BATTERY, 0.001}},
	// Skin thermal sensors. We use back_therm for walleye. For taimen we use
	// bd_therm and bd_therm2.
	{"back_therm", {TemperatureType::SKIN, 1.}},
	{"bd_therm", {TemperatureType::SKIN, 1.}},
	{"bd_therm2", {TemperatureType::SKIN, 1.}},
	// USBC thermal sensor.
	{"usb_port_temp", {TemperatureType::UNKNOWN, 0.1}},
	};

	namespace {

	using ::android::hardware::thermal::V1_0::TemperatureType;

	static std::string gSkinSensorType;
	static unsigned int gSkinThrottlingThreshold;
	static unsigned int gSkinShutdownThreshold;
	static unsigned int gVrThrottledBelowMin;
	Sensors gSensors;

	// A map containing hardcoded thresholds per sensor type. Its not const
	// because initThermal() will modify the skin sensor thresholds depending on the
	// hardware type. The tuple is formatted as follows:
	// <throttling threshold, shutdown threshold, vr threshold>
	std::unordered_map<TemperatureType, std::tuple<float, float, float>>
	gSensorTypeToThresholdsMap = {
	{TemperatureType::CPU, {kCpuThrottlingThreshold, kCpuShutdownThreshold,
	kCpuThrottlingThreshold}},
	{TemperatureType::GPU, {NAN, NAN, NAN}},
	{TemperatureType::BATTERY, {NAN, kBatteryShutdownThreshold, NAN}},
	{TemperatureType::SKIN, {NAN, NAN, NAN}},
	{TemperatureType::UNKNOWN, {NAN, NAN, NAN}}
	};

	bool initializeSensors() {
	auto thermal_zone_dir = std::unique_ptr<DIR, int ()(DIR)>(
	opendir(kThermalSensorsRoot), closedir);
	struct dirent* dp;
	size_t num_thermal_zones = 0;
	while ((dp = readdir(thermal_zone_dir.get())) != nullptr) {
	std::string dir_name(dp->d_name);
	if (dir_name.find(kThermalZoneDirSuffix) != std::string::npos) {
	++num_thermal_zones;
	}
	}

	for (size_t sensor_zone_num = 0; sensor_zone_num < num_thermal_zones;
	++sensor_zone_num) {
	std::string path = android::base::StringPrintf("%s/%s%zu",
	kThermalSensorsRoot,
	kThermalZoneDirSuffix,
	sensor_zone_num);
	std::string sensor_name;
	if (android::base::ReadFileToString(
	path + "/" + kSensorTypeFileSuffix, &sensor_name)) {
	sensor_name = android::base::Trim(sensor_name);
	if (kValidThermalSensorsMap.find(sensor_name) !=
	kValidThermalSensorsMap.end()) {
	TemperatureType type = std::get<0>(
	kValidThermalSensorsMap.at(sensor_name));
	auto thresholds = gSensorTypeToThresholdsMap.at(type);
	if (!gSensors.addSensor(
	sensor_name, path + "/" + kTemperatureFileSuffix,
	std::get<0>(thresholds), std::get<1>(thresholds),
	std::get<2>(thresholds), type)) {
	LOG(ERROR) << "Could not add " << sensor_name
	<< "to sensors map";
	}
	}
	}
	}
	return (gSensors.getNumSensors() == kTemperatureNum);
	}

	} // namespace

	/**
	* 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";
	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";
	gSkinThrottlingThreshold = kTaimenRabSkinThrottlingThreshold;
	gSkinShutdownThreshold = kTaimenRabSkinShutdownThreshold;
	gVrThrottledBelowMin = kTaimenRabVrThrottledBelowMin;
	} else {
	LOG(ERROR) << "Initialization on Taimen revision C and later";
	gSkinThrottlingThreshold = kTaimenRcSkinThrottlingThreshold;
	gSkinShutdownThreshold = kTaimenRcSkinShutdownThreshold;
	gVrThrottledBelowMin = kTaimenRcVrThrottledBelowMin;
	}
	} else {
	LOG(ERROR) << "Unsupported hardware: " << hardware;
	return false;
	}
	gSensorTypeToThresholdsMap[TemperatureType::SKIN] =
	std::make_tuple(gSkinThrottlingThreshold, gSkinShutdownThreshold,
	gVrThrottledBelowMin);
	return initializeSensors();
	}

	ssize_t fillTemperatures(hidl_vec<Temperature>* temperatures) {
	temperatures->resize(gSensors.getNumSensors());
	ssize_t current_index = 0;
	for (const auto& name_type_mult_pair : kValidThermalSensorsMap) {
	Temperature temp;
	if (gSensors.readTemperature(name_type_mult_pair.first,
	std::get<1>(name_type_mult_pair.second),
	&temp)) {
	(*temperatures)[current_index] = temp;
	++current_index;
	}
	}
	return current_index;
	}

	ssize_t fillCpuUsages(hidl_vec<CpuUsage> *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<bool>(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;
	}

	std::string getTargetSkinSensorType() {
	return gSkinSensorType;
	}

	} // namespace implementation
	} // namespace V1_1
	} // namespace thermal
	} // namespace hardware
	} // namespace android