thermal/thermal_exynos.cpp - LeafOS-Devices/android_hardware_samsung_slsi-linaro_exynos - Gitiles

 /*
  * 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 <iostream>
 #include <fstream>
 #include <vector>
 #include <string>
 #include <sstream>
 #include <cstdlib>

 #define LOG_TAG "ThermalHAL"
 #include <log/log.h>
 #include <android-base/logging.h>

 #include <hardware/hardware.h>
 #include <hardware/thermal.h>

 #include "Thermal.h"

 using namespace std;

 namespace android {
 namespace hardware {
 namespace thermal {
 namespace V2_0 {
 namespace implementation {

 using ::android::hardware::thermal::V1_0::ThermalStatus;
 using ::android::hardware::thermal::V1_0::ThermalStatusCode;

 map<string, ifstream> temperatureNodes;
 map<string, vector<ifstream>> throttleNodes;
 map<string, vector<ifstream>> hysteresisNodes;
 map<TemperatureType, vector<string>> thermalNames;
 vector<ifstream> cpuOnlineNodes;
 ifstream cpuUsageNode;

 map<CoolingType, vector<string>> cdevNames;
 map<string, ifstream> cdevCurStates;

 string thermalZonePath = "/sys/class/thermal/thermal_zone";
 string coolingDevicePath = "/sys/class/thermal/cooling_device";
 string cpuPath = "/sys/devices/system/cpu/cpu";

 unsigned int readValue(ifstream &node) {
 	string buf;

 	node.seekg(0, node.beg);
 	node >> buf;
 	return atoi(buf.c_str());
 }

 unsigned int readCurTemp(string &thermalName) {
 	return readValue(temperatureNodes[thermalName]);
 }

 unsigned int readThrottleTemp(string &thermalName, int lv) {
 	return readValue(throttleNodes[thermalName][lv]);
 }

 unsigned int readCpuOnline(int cpuNum) {
 	return readValue(cpuOnlineNodes[cpuNum]);
 }

 unsigned int readCurCdevState(string &cdevName) {
 	return readValue(cdevCurStates[cdevName]);
 }

 unsigned int readHysteresisTemp(string &thermalName, int lv) {
 	return readValue(hysteresisNodes[thermalName][lv]);
 }

 void initExynosThermalHal(void) {
 	int i = 0;
 	while (true) {
 		string curThermalZonePath = thermalZonePath + to_string(i);
 		i++;
 		ifstream zoneTypeNode(curThermalZonePath + "/type");
 		if (!zoneTypeNode.is_open())
 			break;

 		string zoneName;
 		TemperatureType tempType;
 		zoneTypeNode >> zoneName;
 		if (zoneName == "BIG" || zoneName == "MID" || zoneName == "LITTLE") {
 			tempType = TemperatureType::CPU;
 		}
 		else if (zoneName == "G3D") {
 			tempType = TemperatureType::GPU;
 		}
 		else if (zoneName == "NPU") {
 			tempType = TemperatureType::NPU;
 		}
 		else {
 			continue;
 		}

 		// Set temperature node
 		temperatureNodes[zoneName].open(curThermalZonePath + "/temp");
 		thermalNames[tempType].push_back(zoneName);

 		// Set throttling node
 		for (int j = 1; j < 8; j++) {
 			throttleNodes[zoneName].emplace_back(
 					curThermalZonePath + "/trip_point_" + to_string(j) + "_temp");
 			hysteresisNodes[zoneName].emplace_back(
 				curThermalZonePath + "/trip_point_" + to_string(j) + "_hyst");
 		}
 	}

 	i = 0;
 	while (true) {
 		string curCdevPath = coolingDevicePath + to_string(i++);
 		ifstream cdevTypeNode(curCdevPath + "/type");
 		if (!cdevTypeNode.is_open())
 			break;

 		string cdevName;
 		CoolingType cdevType;
 		cdevTypeNode >> cdevName;
 		if (cdevName.find("cpufreq") != string::npos) {
 			cdevType = CoolingType::CPU;
 		}
 		else if (cdevName.find("gpufreq") != string::npos) {
 			cdevType = CoolingType::GPU;
 		}
 		else if (cdevName.find("npu") != string::npos) {
 			cdevType = CoolingType::NPU;
 		}
 		else {
 			continue;
 		}

 		// Set cooling device node
 		cdevNames[cdevType].push_back(cdevName);
 		cdevCurStates[cdevName].open(curCdevPath + "/cur_state");
 	}

 	i = 0;
 	while (true) {
 		string curCpuPath = cpuPath + to_string(i) + "/online";
 		ifstream onlineNode(curCpuPath);

 		if (!onlineNode.is_open())
 			break;

 		cpuOnlineNodes.emplace_back(curCpuPath);
 		i++;
 	}
 }

 ThermalStatus getAllTemperatures(hidl_vec<Temperature_1_0> &temperatures)
 {
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;
 	unsigned int cnt = 0;

 	temperatures.resize(temperatureNodes.size());

 	for (auto it = thermalNames.begin(); it != thermalNames.end(); it++) {
 		for (int i = 0; i < it->second.size(); i++) {
 			string &name = it->second[i];
 			temperatures[cnt].currentValue = readCurTemp(name) / 1000;
 			temperatures[cnt].throttlingThreshold = readThrottleTemp(name, 0);
 			temperatures[cnt].shutdownThreshold = readThrottleTemp(name, 6);
 			temperatures[cnt].vrThrottlingThreshold = UNKNOWN_TEMPERATURE;
 			temperatures[cnt].type = static_cast<::android::hardware::thermal::V1_0::TemperatureType>(it->first);
 			temperatures[cnt].name = it->second[i];
 			cnt++;
 		}
 	}

 	return status;
 }

 ThermalStatus getTypeTemperatures(TemperatureType tType, hidl_vec<Temperature_2_0> &temperatures)
 {
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;
 	vector<string> &tTypeName = thermalNames[tType];

 	if(tTypeName.size() == 0) {
 		status.code = ThermalStatusCode::FAILURE;
 		return status;
 	}

 	temperatures.resize(tTypeName.size());

 	for (int i = 0; i < tTypeName.size(); i++) {
 		string &name = tTypeName[i];
 		unsigned int temp = readCurTemp(name);
 		temperatures[i].value = temp / 1000;
 		temperatures[i].type = tType;
 		temperatures[i].name = tTypeName[i];
 		temperatures[i].throttlingStatus = ThrottlingSeverity::NONE;

 		// Check throttle status
 		for (int j = throttleNodes.size() - 1; j >= 0; j--) {
 			if (temp >= readThrottleTemp(name, j)) {
 				temperatures[i].throttlingStatus = (ThrottlingSeverity)j;
 				break;
 			}
 		}
 	}

 	return status;
 }

 ThermalStatus getCpuUsage(hidl_vec<CpuUsage> &cpuUsage) {
 	string str, value;
 	stringstream line;
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;
 	bool flag = true;
 	string statPath = "/proc/stat";
 	ifstream statNode(statPath);
 	unsigned int cpuNum = 0;

 	cpuUsage.resize(cpuOnlineNodes.size());

 	while (!statNode.eof()) {
 		getline(statNode, str);
 		if (!str.length())
 			break;

 		line.str(str);
 		line >> value;

 		unsigned long long user, nice, system, idle, active, total;

 		if (value != "cpu0" && flag)
 			continue;

 		if (value.compare(0, 3, "cpu")) {
 			flag = true;
 			continue;
 		}
 		else
 			flag = false;

 		line >> user >> nice >> system >> idle;
 		active = user + nice + system;
 		total = active + idle;

 		cpuUsage[cpuNum].name = value;
 		cpuUsage[cpuNum].active = active;
 		cpuUsage[cpuNum].total = total;
 		cpuUsage[cpuNum].isOnline = 1;
 		cpuNum++;
 	}

 	return status;
 }

 /* NOT SUPPORT FAN COOLING DEVICE */
 ThermalStatus coolingDevices(vector<CoolingDevice_1_0> cdevs) {
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;

 	cdevs.clear();

 	return status;
 }

 ThermalStatus curCoolingDevices(CoolingType type, hidl_vec<CoolingDevice_2_0> &cdevs) {
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;
 	vector<string> &typeCdevNames = cdevNames[type];

 	if (typeCdevNames.size() == 0) {
 		status.code = ThermalStatusCode::FAILURE;
 		return status;
 	}

 	cdevs.resize(typeCdevNames.size());

 	for (int i = 0; i < typeCdevNames.size(); i++) {
 		cdevs[i].name = typeCdevNames[i];
 		cdevs[i].type = type;
 		cdevs[i].value = readCurCdevState(typeCdevNames[i]);
 	}

 	return status;
 }

 ThermalStatus temperatureThresholds(TemperatureType tType, vector<TemperatureThreshold> &thresholds) {
 	ThermalStatus status;
 	status.code = ThermalStatusCode::SUCCESS;
 	vector<string> &zoneNames = thermalNames[tType];

 	if (zoneNames.size() == 0) {
 		status.code = ThermalStatusCode::FAILURE;
 		return status;
 	}

 	thresholds.resize(zoneNames.size());

 	for (int i = 0; i < zoneNames.size(); i++) {
 		thresholds[i].type = tType;
 		thresholds[i].name = zoneNames[i];
 		thresholds[i].vrThrottlingThreshold = UNKNOWN_TEMPERATURE;
 		for (int j = 0; j < throttleNodes[zoneNames[i]].size(); j++) {
 			thresholds[i].hotThrottlingThresholds[j] = readThrottleTemp(zoneNames[i], j);
 			thresholds[i].coldThrottlingThresholds[j] = thresholds[i].hotThrottlingThresholds[j] - readHysteresisTemp(zoneNames[i], j);
 		}
 	}

 	return status;
 }

 bool ThermalNotifier::startWatchingDeviceFiles() {
 	if (cb_) {
 		auto ret = this->run("FileNotifierThread", PRIORITY_HIGHEST);
 		if (ret != NO_ERROR) {
 			LOG(ERROR) << "ThermalNotifierThread start fail";
 			return false;
 		} else {
 			LOG(INFO) << "ThermalNotifierThread started";
 			return true;
 		}
 	}
 	return false;
 }

 bool ThermalNotifier::threadLoop() {
 	hidl_vec<Temperature_2_0> getTemps;
 	std::vector<Temperature_2_0> sendTemps;

 	LOG(VERBOSE) << "ThermalNotifier polling...";

 	this_thread::sleep_for(chrono::milliseconds(2000));
 	for (auto it = thermalNames.begin(); it != thermalNames.end(); it++) {
 		getTypeTemperatures(it->first, getTemps);
 		for (auto &t : getTemps) {
 			LOG(VERBOSE) << "ThermalNotifier push_back :" << t.name;
 			sendTemps.push_back(t);
 		}
 	}

 	if (cb_)
 		cb_(sendTemps);

 	return true;
 }

 }  // namespace implementation
 }  // namespace V2_0
 }  // 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 <iostream>
	#include <fstream>
	#include <vector>
	#include <string>
	#include <sstream>
	#include <cstdlib>

	#define LOG_TAG "ThermalHAL"
	#include <log/log.h>
	#include <android-base/logging.h>

	#include <hardware/hardware.h>
	#include <hardware/thermal.h>

	#include "Thermal.h"

	using namespace std;

	namespace android {
	namespace hardware {
	namespace thermal {
	namespace V2_0 {
	namespace implementation {

	using ::android::hardware::thermal::V1_0::ThermalStatus;
	using ::android::hardware::thermal::V1_0::ThermalStatusCode;

	map<string, ifstream> temperatureNodes;
	map<string, vector<ifstream>> throttleNodes;
	map<string, vector<ifstream>> hysteresisNodes;
	map<TemperatureType, vector<string>> thermalNames;
	vector<ifstream> cpuOnlineNodes;
	ifstream cpuUsageNode;

	map<CoolingType, vector<string>> cdevNames;
	map<string, ifstream> cdevCurStates;

	string thermalZonePath = "/sys/class/thermal/thermal_zone";
	string coolingDevicePath = "/sys/class/thermal/cooling_device";
	string cpuPath = "/sys/devices/system/cpu/cpu";

	unsigned int readValue(ifstream &node) {
	string buf;

	node.seekg(0, node.beg);
	node >> buf;
	return atoi(buf.c_str());
	}

	unsigned int readCurTemp(string &thermalName) {
	return readValue(temperatureNodes[thermalName]);
	}

	unsigned int readThrottleTemp(string &thermalName, int lv) {
	return readValue(throttleNodes[thermalName][lv]);
	}

	unsigned int readCpuOnline(int cpuNum) {
	return readValue(cpuOnlineNodes[cpuNum]);
	}

	unsigned int readCurCdevState(string &cdevName) {
	return readValue(cdevCurStates[cdevName]);
	}

	unsigned int readHysteresisTemp(string &thermalName, int lv) {
	return readValue(hysteresisNodes[thermalName][lv]);
	}

	void initExynosThermalHal(void) {
	int i = 0;
	while (true) {
	string curThermalZonePath = thermalZonePath + to_string(i);
	i++;
	ifstream zoneTypeNode(curThermalZonePath + "/type");
	if (!zoneTypeNode.is_open())
	break;

	string zoneName;
	TemperatureType tempType;
	zoneTypeNode >> zoneName;
	if (zoneName == "BIG" \|\| zoneName == "MID" \|\| zoneName == "LITTLE") {
	tempType = TemperatureType::CPU;
	}
	else if (zoneName == "G3D") {
	tempType = TemperatureType::GPU;
	}
	else if (zoneName == "NPU") {
	tempType = TemperatureType::NPU;
	}
	else {
	continue;
	}

	// Set temperature node
	temperatureNodes[zoneName].open(curThermalZonePath + "/temp");
	thermalNames[tempType].push_back(zoneName);

	// Set throttling node
	for (int j = 1; j < 8; j++) {
	throttleNodes[zoneName].emplace_back(
	curThermalZonePath + "/trip_point_" + to_string(j) + "_temp");
	hysteresisNodes[zoneName].emplace_back(
	curThermalZonePath + "/trip_point_" + to_string(j) + "_hyst");
	}
	}

	i = 0;
	while (true) {
	string curCdevPath = coolingDevicePath + to_string(i++);
	ifstream cdevTypeNode(curCdevPath + "/type");
	if (!cdevTypeNode.is_open())
	break;

	string cdevName;
	CoolingType cdevType;
	cdevTypeNode >> cdevName;
	if (cdevName.find("cpufreq") != string::npos) {
	cdevType = CoolingType::CPU;
	}
	else if (cdevName.find("gpufreq") != string::npos) {
	cdevType = CoolingType::GPU;
	}
	else if (cdevName.find("npu") != string::npos) {
	cdevType = CoolingType::NPU;
	}
	else {
	continue;
	}

	// Set cooling device node
	cdevNames[cdevType].push_back(cdevName);
	cdevCurStates[cdevName].open(curCdevPath + "/cur_state");
	}

	i = 0;
	while (true) {
	string curCpuPath = cpuPath + to_string(i) + "/online";
	ifstream onlineNode(curCpuPath);

	if (!onlineNode.is_open())
	break;

	cpuOnlineNodes.emplace_back(curCpuPath);
	i++;
	}
	}

	ThermalStatus getAllTemperatures(hidl_vec<Temperature_1_0> &temperatures)
	{
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;
	unsigned int cnt = 0;

	temperatures.resize(temperatureNodes.size());

	for (auto it = thermalNames.begin(); it != thermalNames.end(); it++) {
	for (int i = 0; i < it->second.size(); i++) {
	string &name = it->second[i];
	temperatures[cnt].currentValue = readCurTemp(name) / 1000;
	temperatures[cnt].throttlingThreshold = readThrottleTemp(name, 0);
	temperatures[cnt].shutdownThreshold = readThrottleTemp(name, 6);
	temperatures[cnt].vrThrottlingThreshold = UNKNOWN_TEMPERATURE;
	temperatures[cnt].type = static_cast<::android::hardware::thermal::V1_0::TemperatureType>(it->first);
	temperatures[cnt].name = it->second[i];
	cnt++;
	}
	}

	return status;
	}

	ThermalStatus getTypeTemperatures(TemperatureType tType, hidl_vec<Temperature_2_0> &temperatures)
	{
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;
	vector<string> &tTypeName = thermalNames[tType];

	if(tTypeName.size() == 0) {
	status.code = ThermalStatusCode::FAILURE;
	return status;
	}

	temperatures.resize(tTypeName.size());

	for (int i = 0; i < tTypeName.size(); i++) {
	string &name = tTypeName[i];
	unsigned int temp = readCurTemp(name);
	temperatures[i].value = temp / 1000;
	temperatures[i].type = tType;
	temperatures[i].name = tTypeName[i];
	temperatures[i].throttlingStatus = ThrottlingSeverity::NONE;

	// Check throttle status
	for (int j = throttleNodes.size() - 1; j >= 0; j--) {
	if (temp >= readThrottleTemp(name, j)) {
	temperatures[i].throttlingStatus = (ThrottlingSeverity)j;
	break;
	}
	}
	}

	return status;
	}

	ThermalStatus getCpuUsage(hidl_vec<CpuUsage> &cpuUsage) {
	string str, value;
	stringstream line;
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;
	bool flag = true;
	string statPath = "/proc/stat";
	ifstream statNode(statPath);
	unsigned int cpuNum = 0;

	cpuUsage.resize(cpuOnlineNodes.size());

	while (!statNode.eof()) {
	getline(statNode, str);
	if (!str.length())
	break;

	line.str(str);
	line >> value;

	unsigned long long user, nice, system, idle, active, total;

	if (value != "cpu0" && flag)
	continue;

	if (value.compare(0, 3, "cpu")) {
	flag = true;
	continue;
	}
	else
	flag = false;

	line >> user >> nice >> system >> idle;
	active = user + nice + system;
	total = active + idle;

	cpuUsage[cpuNum].name = value;
	cpuUsage[cpuNum].active = active;
	cpuUsage[cpuNum].total = total;
	cpuUsage[cpuNum].isOnline = 1;
	cpuNum++;
	}

	return status;
	}

	/* NOT SUPPORT FAN COOLING DEVICE */
	ThermalStatus coolingDevices(vector<CoolingDevice_1_0> cdevs) {
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;

	cdevs.clear();

	return status;
	}

	ThermalStatus curCoolingDevices(CoolingType type, hidl_vec<CoolingDevice_2_0> &cdevs) {
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;
	vector<string> &typeCdevNames = cdevNames[type];

	if (typeCdevNames.size() == 0) {
	status.code = ThermalStatusCode::FAILURE;
	return status;
	}

	cdevs.resize(typeCdevNames.size());

	for (int i = 0; i < typeCdevNames.size(); i++) {
	cdevs[i].name = typeCdevNames[i];
	cdevs[i].type = type;
	cdevs[i].value = readCurCdevState(typeCdevNames[i]);
	}

	return status;
	}

	ThermalStatus temperatureThresholds(TemperatureType tType, vector<TemperatureThreshold> &thresholds) {
	ThermalStatus status;
	status.code = ThermalStatusCode::SUCCESS;
	vector<string> &zoneNames = thermalNames[tType];

	if (zoneNames.size() == 0) {
	status.code = ThermalStatusCode::FAILURE;
	return status;
	}

	thresholds.resize(zoneNames.size());

	for (int i = 0; i < zoneNames.size(); i++) {
	thresholds[i].type = tType;
	thresholds[i].name = zoneNames[i];
	thresholds[i].vrThrottlingThreshold = UNKNOWN_TEMPERATURE;
	for (int j = 0; j < throttleNodes[zoneNames[i]].size(); j++) {
	thresholds[i].hotThrottlingThresholds[j] = readThrottleTemp(zoneNames[i], j);
	thresholds[i].coldThrottlingThresholds[j] = thresholds[i].hotThrottlingThresholds[j] - readHysteresisTemp(zoneNames[i], j);
	}
	}

	return status;
	}

	bool ThermalNotifier::startWatchingDeviceFiles() {
	if (cb_) {
	auto ret = this->run("FileNotifierThread", PRIORITY_HIGHEST);
	if (ret != NO_ERROR) {
	LOG(ERROR) << "ThermalNotifierThread start fail";
	return false;
	} else {
	LOG(INFO) << "ThermalNotifierThread started";
	return true;
	}
	}
	return false;
	}

	bool ThermalNotifier::threadLoop() {
	hidl_vec<Temperature_2_0> getTemps;
	std::vector<Temperature_2_0> sendTemps;

	LOG(VERBOSE) << "ThermalNotifier polling...";

	this_thread::sleep_for(chrono::milliseconds(2000));
	for (auto it = thermalNames.begin(); it != thermalNames.end(); it++) {
	getTypeTemperatures(it->first, getTemps);
	for (auto &t : getTemps) {
	LOG(VERBOSE) << "ThermalNotifier push_back :" << t.name;
	sendTemps.push_back(t);
	}
	}

	if (cb_)
	cb_(sendTemps);

	return true;
	}

	} // namespace implementation
	} // namespace V2_0
	} // namespace thermal
	} // namespace hardware
	} // namespace android