dptf: Add support for generation of Active Policies

This change adds support for generating the different pieces of DPTF
Active Policies. This includes the Active Relationship Table, in
addition to _ACx methods.

BUG=b:143539650
TEST=compiles

Change-Id: Iea0ccbd96f88d0f3a8f2c77a7d0f3a284e5ee463
Signed-off-by: Tim Wawrzynczak <twawrzynczak@chromium.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/41885
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Sumeet R Pawnikar <sumeet.r.pawnikar@intel.com>
Reviewed-by: Duncan Laurie <dlaurie@chromium.org>

5 files changed, 249 insertions, 12 deletions

diff --git a/src/acpi/Makefile.inc b/src/acpi/Makefile.inc
index 29ddc08d96..f70b23ff5b 100644
--- a/src/acpi/Makefile.inc
+++ b/src/acpi/Makefile.inc
@@ -4,6 +4,7 @@ ifeq ($(CONFIG_HAVE_ACPI_TABLES),y)
 
 ramstage-y += acpi.c
 ramstage-y += acpigen.c
+ramstage-y += acpigen_dptf.c
 ramstage-y += acpigen_dsm.c
 ramstage-y += acpigen_ps2_keybd.c
 ramstage-y += acpigen_usb.c
diff --git a/src/acpi/acpigen_dptf.c b/src/acpi/acpigen_dptf.c
new file mode 100644
index 0000000000..74e91910bb
--- /dev/null
+++ b/src/acpi/acpigen_dptf.c
@@ -0,0 +1,166 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+
+#include <acpi/acpigen.h>
+#include <acpi/acpigen_dptf.h>
+
+/* Hardcoded paths */
+#define TOPLEVEL_DPTF_SCOPE		"\\_SB.DPTF"
+
+/* Defaults */
+enum {
+	ART_REVISION			= 0,
+	DEFAULT_WEIGHT			= 100,
+	DPTF_MAX_ART_THRESHOLDS		= 10,
+};
+
+/* Convert degrees C to 1/10 degree Kelvin for ACPI */
+static int to_acpi_temp(int deg_c)
+{
+	return deg_c * 10 + 2732;
+}
+
+/* Writes out a 0-argument non-Serialized Method that returns an Integer */
+static void write_simple_return_method(const char *name, int value)
+{
+	acpigen_write_method(name, 0);
+	acpigen_write_return_integer(value);
+	acpigen_pop_len(); /* Method */
+}
+
+/* Return the assigned namestring of any participant */
+static const char *namestring_of(enum dptf_participant participant)
+{
+	switch (participant) {
+	case DPTF_CPU:
+		return "TCPU";
+	case DPTF_CHARGER:
+		return "TCHG";
+	case DPTF_FAN:
+		return "TFN1";
+	case DPTF_TEMP_SENSOR_0:
+		return "TSR0";
+	case DPTF_TEMP_SENSOR_1:
+		return "TSR1";
+	case DPTF_TEMP_SENSOR_2:
+		return "TSR2";
+	case DPTF_TEMP_SENSOR_3:
+		return "TSR3";
+	default:
+		return "";
+	}
+}
+
+/* Helper to get Scope for participants underneath \_SB.DPTF */
+static const char *scope_of(enum dptf_participant participant)
+{
+	static char scope[16];
+
+	if (participant == DPTF_CPU)
+		snprintf(scope, sizeof(scope), "\\_SB.%s", namestring_of(participant));
+	else
+		snprintf(scope, sizeof(scope), TOPLEVEL_DPTF_SCOPE ".%s",
+			 namestring_of(participant));
+
+	return scope;
+}
+
+/* Write out scope of a participant */
+void dptf_write_scope(enum dptf_participant participant)
+{
+	acpigen_write_scope(scope_of(participant));
+}
+
+/*
+ * This table describes active cooling relationships between the system's fan and the
+ * temperature sensors that it can have an effect on. As ever-increasing temperature thresholds
+ * are crossed (_AC9.._AC0, low to high), the corresponding fan percentages listed in this table
+ * are used to increase the speed of the fan in order to speed up cooling.
+ */
+static void write_active_relationship_table(const struct dptf_active_policy *policies,
+					    int max_count)
+{
+	char *pkg_count;
+	int i, j;
+
+	/* Nothing to do */
+	if (!max_count || policies[0].target == DPTF_NONE)
+		return;
+
+	acpigen_write_scope(TOPLEVEL_DPTF_SCOPE);
+	acpigen_write_method("_ART", 0);
+
+	/* Return this package */
+	acpigen_emit_byte(RETURN_OP);
+
+	/* Keep track of items added to the package */
+	pkg_count = acpigen_write_package(1); /* The '1' here is for the revision */
+	acpigen_write_integer(ART_REVISION);
+
+	for (i = 0; i < max_count; ++i) {
+		/*
+		 * These have to be filled out from AC0 down to AC9, filling in only as many
+		 * as are used. As soon as one isn't filled in, we're done.
+		 */
+		if (policies[i].target == DPTF_NONE)
+			break;
+
+		(*pkg_count)++;
+
+		/* Source, Target, Percent, Fan % for each of _AC0 ... _AC9 */
+		acpigen_write_package(13);
+		acpigen_emit_namestring(namestring_of(DPTF_FAN));
+		acpigen_emit_namestring(namestring_of(policies[i].target));
+		acpigen_write_integer(DEFAULT_IF_0(policies[i].weight, DEFAULT_WEIGHT));
+
+		/* Write out fan %; corresponds with target's _ACx methods */
+		for (j = 0; j < DPTF_MAX_ART_THRESHOLDS; ++j)
+			acpigen_write_integer(policies[i].thresholds[j].fan_pct);
+
+		acpigen_pop_len(); /* inner Package */
+	}
+
+	acpigen_pop_len(); /* outer Package */
+	acpigen_pop_len(); /* Method _ART */
+	acpigen_pop_len(); /* Scope */
+}
+
+/*
+ * _AC9 through _AC0 represent temperature thresholds, in increasing order, defined from _AC0
+ * down, that, when reached, DPTF will activate TFN1 in order to actively cool the temperature
+ * sensor(s). As increasing thresholds are reached, the fan is spun faster.
+ */
+static void write_active_cooling_methods(const struct dptf_active_policy *policies,
+					 int max_count)
+{
+	char name[5];
+	int i, j;
+
+	/* Nothing to do */
+	if (!max_count || policies[0].target == DPTF_NONE)
+		return;
+
+	for (i = 0; i < max_count; ++i) {
+		if (policies[i].target == DPTF_NONE)
+			break;
+
+		dptf_write_scope(policies[i].target);
+
+		/* Write out as many of _AC0 through _AC9 that are applicable */
+		for (j = 0; j < DPTF_MAX_ACX; ++j) {
+			if (!policies[i].thresholds[j].temp)
+				break;
+
+			snprintf(name, sizeof(name), "_AC%1X", j);
+			write_simple_return_method(name, to_acpi_temp(
+							   policies[i].thresholds[j].temp));
+		}
+
+		acpigen_pop_len(); /* Scope */
+	}
+}
+
+void dptf_write_active_policies(const struct dptf_active_policy *policies, int max_count)
+{
+	write_active_relationship_table(policies, max_count);
+	write_active_cooling_methods(policies, max_count);
+}
diff --git a/src/drivers/intel/dptf/chip.h b/src/drivers/intel/dptf/chip.h
index 704b83e763..730d23ed6b 100644
--- a/src/drivers/intel/dptf/chip.h
+++ b/src/drivers/intel/dptf/chip.h
@@ -3,7 +3,12 @@
 #ifndef _DRIVERS_INTEL_DPTF_CHIP_H_
 #define _DRIVERS_INTEL_DPTF_CHIP_H_
 
+#include <acpi/acpigen_dptf.h>
+
 struct drivers_intel_dptf_config {
+	struct {
+		struct dptf_active_policy active[DPTF_MAX_ACTIVE_POLICIES];
+	} policies;
 };
 
 #endif /* _DRIVERS_INTEL_DPTF_CHIP_H_ */
diff --git a/src/drivers/intel/dptf/dptf.c b/src/drivers/intel/dptf/dptf.c
index 060864adc1..20f8d9b4ae 100644
--- a/src/drivers/intel/dptf/dptf.c
+++ b/src/drivers/intel/dptf/dptf.c
@@ -5,18 +5,6 @@
 #include <device/device.h>
 #include "chip.h"
 
-enum dptf_participant {
-	DPTF_NONE,
-	DPTF_CPU,
-	DPTF_CHARGER,
-	DPTF_FAN,
-	DPTF_TEMP_SENSOR_0,
-	DPTF_TEMP_SENSOR_1,
-	DPTF_TEMP_SENSOR_2,
-	DPTF_TEMP_SENSOR_3,
-	DPTF_PARTICIPANT_COUNT,
-};
-
 /* Generic DPTF participants have a PTYP field to distinguish them */
 enum dptf_generic_participant_type {
 	DPTF_GENERIC_PARTICIPANT_TYPE_TSR	= 0x3,
@@ -40,6 +28,17 @@ enum dptf_generic_participant_type {
 static bool is_participant_used(const struct drivers_intel_dptf_config *config,
 				enum dptf_participant participant)
 {
+	int i;
+
+	/* Active? */
+	for (i = 0; i < DPTF_MAX_ACTIVE_POLICIES; ++i)
+		if (config->policies.active[i].target == participant)
+			return true;
+
+	/* Check fan as well (its use is implicit in the Active policy) */
+	if (participant == DPTF_FAN && config->policies.active[0].target != DPTF_NONE)
+		return true;
+
 	return false;
 }
 
@@ -53,6 +52,9 @@ static void dptf_fill_ssdt(const struct device *dev)
 {
 	struct drivers_intel_dptf_config *config = config_of(dev);
 
+	dptf_write_active_policies(config->policies.active,
+				   DPTF_MAX_ACTIVE_POLICIES);
+
 	printk(BIOS_INFO, "\\_SB.DPTF: %s at %s\n", dev->chip_ops->name, dev_path(dev));
 }
 
diff --git a/src/include/acpi/acpigen_dptf.h b/src/include/acpi/acpigen_dptf.h
new file mode 100644
index 0000000000..a082b62fd9
--- /dev/null
+++ b/src/include/acpi/acpigen_dptf.h
@@ -0,0 +1,63 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+
+#ifndef ACPI_ACPIGEN_DPTF_H
+#define ACPI_ACPIGEN_DPTF_H
+
+#include <device/device.h>
+#include <stdbool.h>
+
+/* A common idiom is to use a default value if none is provided (i.e., == 0) */
+#define DEFAULT_IF_0(thing, default_) ((thing) ? (thing) : (default_))
+
+/* List of available participants (i.e., they can participate in policies) */
+enum dptf_participant {
+	DPTF_NONE,
+	DPTF_CPU,
+	DPTF_CHARGER,
+	DPTF_FAN,
+	DPTF_TEMP_SENSOR_0,
+	DPTF_TEMP_SENSOR_1,
+	DPTF_TEMP_SENSOR_2,
+	DPTF_TEMP_SENSOR_3,
+	DPTF_PARTICIPANT_COUNT,
+};
+
+/* DPTF compile-time constants */
+enum {
+	/* A device can only define _AC0 .. _AC9 i.e. between 0 and 10 Active Cooling Methods */
+	DPTF_MAX_ACX			= 10,
+	DPTF_MAX_ACTIVE_POLICIES	= (DPTF_PARTICIPANT_COUNT-1),
+};
+
+/* Active Policy */
+struct dptf_active_policy {
+	/* Device capable of being affected by the fan */
+	enum dptf_participant target;
+	/* Source's contribution to the Target's cooling capability as a percentage */
+	uint8_t weight;
+	/* When target reaches temperature 'temp', the source will turn on at 'fan_pct' % */
+	struct {
+		/* (degrees C) */
+		uint8_t temp;
+		/* 0 - 100 */
+		uint8_t fan_pct;
+	} thresholds[DPTF_MAX_ACX];
+};
+
+/*
+ * This function provides tables of temperature and corresponding fan or percent.  When the
+ * temperature thresholds are met (_AC0 - _AC9), the fan is driven to corresponding percentage
+ * of full speed.
+ */
+void dptf_write_active_policies(const struct dptf_active_policy *policies, int max_count);
+
+/* Helper method to open the scope for a given participant. */
+void dptf_write_scope(enum dptf_participant participant);
+
+/*
+ * Write out a _STA that will check the value of the DPTE field in GNVS, and return 0xF if DPTE
+ * is 1, otherwise it will return 0.
+ */
+void dptf_write_STA(void);
+
+#endif /* ACPI_ACPIGEN_DPTF_H */