replace common qcom sources with samsung ones

qcom/opensource/thermal-hal/thermalMonitorNetlink.cpp

@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2021, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2022 Qualcomm Innovation Center, Inc. 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.
+ */
+
+ /* Changes from Qualcomm Innovation Center are provided under the following license:
+
+Copyright (c) 2023-2024 Qualcomm Innovation Center, Inc. All rights reserved.
+SPDX-License-Identifier: BSD-3-Clause-Clear */
+
+#include <unistd.h>
+#include <linux/thermal.h>
+#include <android-base/logging.h>
+#include <android-base/properties.h>
+#include <android-base/stringprintf.h>
+
+#include "thermalMonitorNetlink.h"
+
+namespace aidl {
+namespace android {
+namespace hardware {
+namespace thermal {
+
+using pollCB = std::function<bool()>;
+using familyCB = std::function<int(struct nl_msg *, void *)>;
+
+void thermal_listen(struct nl_sock *soc, const pollCB &stopCB)
+{
+	while (!stopCB())
+		nl_recvmsgs_default(soc);
+
+	LOG(INFO) << "thermal_listen_event Exit" << std::endl;
+	return;
+}
+
+int thermal_event_cb(struct nl_msg *n, void *data)
+{
+	ThermalMonitor *t = (ThermalMonitor *)data;
+	return t->event_parse(n, NULL);
+}
+
+int thermal_sample_cb(struct nl_msg *n, void *data)
+{
+	ThermalMonitor *t = (ThermalMonitor *)data;
+	return t->sample_parse(n, NULL);
+}
+
+int thermal_family_cb(struct nl_msg *n, void *data)
+{
+	ThermalMonitor *t = (ThermalMonitor *)data;
+	return t->family_msg_cb(n, NULL);
+}
+
+ThermalMonitor::ThermalMonitor(const eventMonitorCB &inp_event_cb,
+				const eventMonitorCB &inp_sample_cb,
+				const eventCreateMonitorCB &inp_event_create_cb,
+				const eventMonitorCB &inp_event_cdev_cb):
+	event_group(-1),
+	sample_group(-1),
+	event_cb(inp_event_cb),
+	sample_cb(inp_sample_cb),
+	event_create_cb(inp_event_create_cb),
+	cdev_cb(inp_event_cdev_cb)
+{
+	monitor_shutdown = false;
+}
+
+ThermalMonitor::~ThermalMonitor()
+{
+	monitor_shutdown = true;
+	event_th.join();
+	sample_th.join();
+	if (sample_soc)
+		nl_socket_free(sample_soc);
+	if (event_soc)
+		nl_socket_free(event_soc);
+}
+
+int ThermalMonitor::event_parse(struct nl_msg *n, void *data)
+{
+	struct nlmsghdr *nl_hdr = nlmsg_hdr(n);
+	struct genlmsghdr *hdr = genlmsg_hdr(nl_hdr);
+	struct nlattr *attrs[THERMAL_GENL_ATTR_MAX + 1];
+	int tzn = -1, trip = -1, cdev_id = -1, curr_state = -1;
+	const char *tz_name = "";
+
+	genlmsg_parse(nl_hdr, 0, attrs, THERMAL_GENL_ATTR_MAX, NULL);
+
+	switch (hdr->cmd) {
+	case THERMAL_GENL_EVENT_TZ_TRIP_UP:
+	case THERMAL_GENL_EVENT_TZ_TRIP_DOWN:
+		if (attrs[THERMAL_GENL_ATTR_TZ_ID])
+			tzn = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
+
+		if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID])
+			trip = nla_get_u32(
+					attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]);
+		LOG(DEBUG) << "thermal_nl_event: TZ:" << tzn << " Trip:"
+		       << trip << "event:" << (int)hdr->cmd << std::endl;
+		event_cb(tzn, trip);
+		break;
+	case THERMAL_GENL_EVENT_TZ_CREATE:
+		if (attrs[THERMAL_GENL_ATTR_TZ_ID])
+			tzn = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
+		if (attrs[THERMAL_GENL_ATTR_TZ_NAME])
+			tz_name = nla_get_string(attrs[THERMAL_GENL_ATTR_TZ_NAME]);
+		LOG(DEBUG) << "thermal_nl_event: TZ_CREATE: TZ:" << tzn << " TZ_NAME:"
+		       << tz_name << "event:" << (int)hdr->cmd << std::endl;
+		event_create_cb(tzn, tz_name);
+		break;
+	case THERMAL_GENL_EVENT_CDEV_STATE_UPDATE:
+		if (attrs[THERMAL_GENL_ATTR_CDEV_ID])
+			cdev_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]);
+		if (attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE])
+			curr_state  = nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE]);
+		LOG(DEBUG) << "thermal_nl_event: CDEV:" << cdev_id <<
+				" curr_state :" << curr_state  << " event:" << (int)hdr->cmd<< std::endl;
+		cdev_cb(cdev_id, curr_state);
+		break;
+	}
+
+	return 0;
+
+}
+
+int ThermalMonitor::sample_parse(struct nl_msg *n, void *data)
+{
+	struct nlmsghdr *nl_hdr = nlmsg_hdr(n);
+	struct genlmsghdr *hdr = genlmsg_hdr(nl_hdr);
+	struct nlattr *attrs[THERMAL_GENL_ATTR_MAX + 1];
+	int tzn = -1, temp = -1;
+
+	genlmsg_parse(nl_hdr, 0, attrs, THERMAL_GENL_ATTR_MAX, NULL);
+
+	switch (hdr->cmd) {
+	case THERMAL_GENL_SAMPLING_TEMP:
+		if (attrs[THERMAL_GENL_ATTR_TZ_ID])
+			tzn = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]);
+
+		if (attrs[THERMAL_GENL_ATTR_TZ_TEMP])
+			temp = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TEMP]);
+
+		LOG(DEBUG) << "thermal_sample_event: TZ:" << tzn << " temp:"
+			<< temp << std::endl;
+		sample_cb(tzn, temp);
+		break;
+	}
+
+	return 0;
+
+}
+
+int ThermalMonitor::family_msg_cb(struct nl_msg *msg, void *data)
+{
+	struct nlattr *tb[CTRL_ATTR_MAX + 1];
+	struct genlmsghdr *gnlh = genlmsg_hdr(nlmsg_hdr(msg));
+	struct nlattr *mc_group;
+	int rem_mcgrp;
+
+	nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
+		  genlmsg_attrlen(gnlh, 0), NULL);
+
+	if (!tb[CTRL_ATTR_MCAST_GROUPS]) {
+		LOG(ERROR) << "Multicast group not available\n";
+		return -1;
+	}
+
+	nla_for_each_nested(mc_group, tb[CTRL_ATTR_MCAST_GROUPS], rem_mcgrp) {
+
+		struct nlattr *nl_group[CTRL_ATTR_MCAST_GRP_MAX + 1];
+
+		nla_parse(nl_group, CTRL_ATTR_MCAST_GRP_MAX,
+			  (struct nlattr *)nla_data(mc_group),
+			  nla_len(mc_group), NULL);
+
+		if (!nl_group[CTRL_ATTR_MCAST_GRP_NAME] ||
+		    !nl_group[CTRL_ATTR_MCAST_GRP_ID])
+			continue;
+		std::string family((char *)nla_data(
+					nl_group[CTRL_ATTR_MCAST_GRP_NAME]));
+		LOG(DEBUG) << "Family:" << family << std::endl;
+		if (family == THERMAL_GENL_EVENT_GROUP_NAME)
+			event_group = nla_get_u32(
+					nl_group[CTRL_ATTR_MCAST_GRP_ID]);
+
+		if (family == THERMAL_GENL_SAMPLING_GROUP_NAME)
+			sample_group = nla_get_u32(
+					nl_group[CTRL_ATTR_MCAST_GRP_ID]);
+	}
+
+	return 0;
+}
+
+int ThermalMonitor::send_nl_msg(struct nl_msg *msg)
+{
+	int ret = 0;
+
+	ret = nl_send_auto(event_soc, msg);
+	if (ret < 0) {
+		LOG(ERROR) << "Error sending NL message\n";
+		return ret;
+	}
+	nl_socket_disable_seq_check(event_soc);
+	nl_socket_modify_cb(event_soc, NL_CB_VALID, NL_CB_CUSTOM,
+			thermal_family_cb, this);
+	ret = nl_recvmsgs_default(event_soc);
+
+	return ret;
+}
+
+int ThermalMonitor::fetch_group_id(void)
+{
+	struct nl_msg *msg;
+	int ctrlid, ret = 0;
+
+	msg = nlmsg_alloc();
+	if (!msg)
+		return -1;
+
+	ctrlid = genl_ctrl_resolve(event_soc, "nlctrl");
+	genlmsg_put(msg, 0, 0, ctrlid, 0, 0, CTRL_CMD_GETFAMILY, 0);
+
+	nla_put_string(msg, CTRL_ATTR_FAMILY_NAME, THERMAL_GENL_FAMILY_NAME);
+	send_nl_msg(msg);
+
+	nlmsg_free(msg);
+
+	if (event_group != -1 && sample_group != -1) {
+		LOG(DEBUG) << "Netlink event: " << event_group <<
+			" Sample:" << sample_group << std::endl;
+		ret = nl_socket_add_membership(event_soc, event_group);
+		if (ret) {
+			LOG(ERROR) << "Netlink event Socket membership add error\n";
+			return ret;
+		}
+
+		ret = nl_socket_add_membership(sample_soc, sample_group);
+		if (ret) {
+			LOG(ERROR) << "Netlink sample Socket membership add error\n";
+			return ret;
+		}
+	}
+	return 0;
+}
+
+void ThermalMonitor::start()
+{
+	struct nl_msg *msg;
+
+	event_soc = nl_socket_alloc();
+	if (!event_soc) {
+		LOG(ERROR) << "Netlink Event socket alloc failed\n";
+		return;
+	}
+
+	if (genl_connect(event_soc)) {
+		LOG(ERROR) << "Netlink Event socket connect failed\n";
+		nl_socket_free(event_soc);
+		event_soc = nullptr;
+		return;
+	}
+
+	sample_soc = nl_socket_alloc();
+	if (!sample_soc) {
+		LOG(ERROR) << "Netlink Sample socket alloc failed\n";
+		nl_socket_free(event_soc);
+		event_soc = nullptr;
+		return;
+	}
+
+	if (genl_connect(sample_soc)) {
+		LOG(ERROR) << "Netlink Sample socket connect failed\n";
+		nl_socket_free(sample_soc);
+		nl_socket_free(event_soc);
+		event_soc = nullptr;
+		sample_soc = nullptr;
+		return;
+	}
+	if (fetch_group_id())
+		return;
+	LOG(DEBUG) << "Netlink connection established.\n";
+	nl_socket_disable_seq_check(sample_soc);
+	nl_socket_modify_cb(sample_soc, NL_CB_VALID, NL_CB_CUSTOM,
+			thermal_sample_cb, this);
+	nl_socket_disable_seq_check(event_soc);
+	nl_socket_modify_cb(event_soc, NL_CB_VALID, NL_CB_CUSTOM,
+			thermal_event_cb, this);
+	event_th = std::thread(thermal_listen, event_soc,
+		std::bind(&ThermalMonitor::stopPolling, this));
+
+	sample_th = std::thread(thermal_listen, sample_soc,
+		std::bind(&ThermalMonitor::stopPolling, this));
+}
+
+}  // namespace thermal
+}  // namespace hardware
+}  // namespace android
+}  // namespace aidl