1 files changed, 45 insertions, 310 deletions

diff --git a/gxp-thermal.c b/gxp-thermal.c
index 8a9c24b..671d140 100644
--- a/gxp-thermal.c
+++ b/gxp-thermal.c
@@ -2,358 +2,93 @@
 /*
  * Platform thermal driver for GXP.
  *
- * Copyright (C) 2021 Google LLC
+ * Copyright (C) 2021-2023 Google LLC
  */
 
 #include <linux/acpm_dvfs.h>
-#include <linux/debugfs.h>
 #include <linux/device.h>
-#include <linux/gfp.h>
-#include <linux/kernel.h>
-#include <linux/mutex.h>
-#include <linux/of.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/slab.h>
-#include <linux/thermal.h>
-#include <linux/version.h>
+#include <linux/minmax.h>
 
 #include <gcip/gcip-pm.h>
+#include <gcip/gcip-thermal.h>
 
-/*
- * thermal_cdev_update is moved to drivers/thermal/thermal_core.h in kernel
- * 5.12. The symbol is still exported, manually declare the function prototype
- * to get rid of the implicit declaration compilation error.
- */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
-void thermal_cdev_update(struct thermal_cooling_device *cdev);
-#endif
-
+#include "gxp-config.h"
 #include "gxp-internal.h"
 #include "gxp-pm.h"
 #include "gxp-thermal.h"
-#include "gxp-lpm.h"
-
 #if GXP_HAS_MCU
 #include "gxp-kci.h"
 #include "gxp-mcu.h"
 #endif /* GXP_HAS_MCU */
 
-/*
- * Value comes from internal measurement
- * b/229623553
- */
-static struct gxp_state_pwr state_pwr_map[] = {
-	{ AUR_NOM_RATE, 78 },
-	{ AUR_UD_PLUS_RATE, 58 },
-	{ AUR_UD_RATE, 40 },
-	{ AUR_SUD_PLUS_RATE, 27 },
-	{ AUR_SUD_RATE, 20 },
-	{ AUR_UUD_PLUS_RATE, 16 },
-	{ AUR_UUD_RATE, 13 },
-};
-
-static int gxp_get_max_state(struct thermal_cooling_device *cdev,
-			     unsigned long *state)
+static int gxp_thermal_get_rate(void *data, unsigned long *rate)
 {
-	struct gxp_thermal_manager *thermal = cdev->devdata;
+	*rate = exynos_acpm_get_rate(AUR_DVFS_DOMAIN, 0);
 
-	if (!thermal->gxp_num_states)
-		return -EIO;
-
-	*state = thermal->gxp_num_states - 1;
 	return 0;
 }
 
-/*
- * Set cooling state.
- */
-static int gxp_set_cur_state(struct thermal_cooling_device *cdev,
-				     unsigned long cooling_state)
+static int gxp_thermal_set_rate(void *data, unsigned long rate)
 {
+	struct gxp_dev *gxp = data;
 	int ret = 0;
-	struct gxp_thermal_manager *thermal = cdev->devdata;
-	struct gxp_dev *gxp = thermal->gxp;
-	struct device *dev = gxp->dev;
-	unsigned long pwr_state;
-
-	if (cooling_state >= thermal->gxp_num_states) {
-		dev_err(dev, "%s: invalid cooling state %lu\n", __func__,
-			cooling_state);
-		return -EINVAL;
-	}
 
-	mutex_lock(&thermal->lock);
-	cooling_state = max(thermal->sysfs_req, cooling_state);
-	if (cooling_state >= ARRAY_SIZE(state_pwr_map)) {
-		dev_err(dev, "Unsupported cooling state: %lu\n", cooling_state);
-		ret = -EINVAL;
-		goto out;
-	}
-	pwr_state = state_pwr_map[cooling_state].state;
-	dev_dbg(dev, "setting state %ld\n", pwr_state);
-	if (cooling_state != thermal->cooling_state) {
-		if (!gxp_is_direct_mode(gxp)) {
+	if (!gxp_is_direct_mode(gxp)) {
 #if GXP_HAS_MCU
-			struct gxp_mcu *mcu = gxp_mcu_of(gxp);
-
-			ret = gcip_pm_get_if_powered(mcu->gxp->power_mgr->pm,
-						     false);
-			if (ret) {
-				dev_err(dev,
-					"Can't acquire wakelock when powered down: %d\n",
-					ret);
-				goto out;
-			}
+		struct gxp_mcu *mcu = gxp_mcu_of(gxp);
 
-			ret = gxp_kci_notify_throttling(&mcu->kci, pwr_state);
-			gcip_pm_put(gxp->power_mgr->pm);
+		ret = gxp_kci_notify_throttling(&mcu->kci, rate);
 #endif /* GXP_HAS_MCU */
-		} else {
-			ret = gxp_pm_blk_set_rate_acpm(
-				gxp,
-				max(pwr_state,
-				    (unsigned long)
-					    aur_power_state2rate[AUR_UUD]));
-		}
-
-		if (ret) {
-			dev_err(dev, "error setting gxp cooling state: %d\n",
-				ret);
-			ret = -ENODEV;
-			goto out;
-		}
-		thermal->cooling_state = cooling_state;
-		gxp_pm_set_thermal_limit(thermal->gxp, pwr_state);
 	} else {
-		ret = -EALREADY;
-	}
-
-out:
-	mutex_unlock(&thermal->lock);
-	return ret;
-}
-
-static int gxp_get_cur_state(struct thermal_cooling_device *cdev,
-			     unsigned long *state)
-{
-	int ret = 0;
-	struct gxp_thermal_manager *thermal = cdev->devdata;
-
-	mutex_lock(&thermal->lock);
-	*state = thermal->cooling_state;
-	if (*state >= thermal->gxp_num_states) {
-		dev_err(thermal->gxp->dev,
-			"Unknown cooling state: %lu, resetting\n", *state);
-		ret = -EINVAL;
-		goto out;
-	}
-out:
-	mutex_unlock(&thermal->lock);
-	return ret;
-}
-
-static int gxp_state2power_internal(unsigned long state, u32 *power,
-				    struct gxp_thermal_manager *thermal)
-{
-	int i;
-
-	for (i = 0; i < thermal->gxp_num_states; i++) {
-		if (state == state_pwr_map[i].state) {
-			*power = state_pwr_map[i].power;
-			return 0;
-		}
+		rate = max_t(unsigned long, rate,
+			     aur_power_state2rate[AUR_UUD]);
+		ret = gxp_pm_blk_set_rate_acpm(gxp, rate);
 	}
-	dev_err(thermal->gxp->dev, "Unknown state req for: %lu\n", state);
-	*power = 0;
-	return -EINVAL;
-}
-
-static int gxp_get_requested_power(struct thermal_cooling_device *cdev,
-				   u32 *power)
-{
-	unsigned long power_state;
-	struct gxp_thermal_manager *cooling = cdev->devdata;
-
-	power_state = exynos_acpm_get_rate(AUR_DVFS_DOMAIN, 0);
-	return gxp_state2power_internal(power_state, power, cooling);
-}
 
-/* TODO(b/213272324): Move state2power table to dts */
-static int gxp_state2power(struct thermal_cooling_device *cdev,
-			       unsigned long state, u32 *power)
-{
-	struct gxp_thermal_manager *thermal = cdev->devdata;
-
-	if (state >= thermal->gxp_num_states) {
-		dev_err(thermal->gxp->dev, "%s: invalid state: %lu\n", __func__,
-			state);
-		return -EINVAL;
+	if (ret) {
+		dev_err(gxp->dev, "error setting gxp cooling state: %d\n", ret);
+		return ret;
 	}
 
-	return gxp_state2power_internal(state_pwr_map[state].state, power,
-					thermal);
-}
-
-static int gxp_power2state(struct thermal_cooling_device *cdev,
-			       u32 power, unsigned long *state)
-{
-	int i, penultimate_throttle_state;
-	struct gxp_thermal_manager *thermal = cdev->devdata;
-
-	*state = 0;
-	/* Less than 2 state means we cannot really throttle */
-	if (thermal->gxp_num_states < 2)
-		return thermal->gxp_num_states == 1 ? 0 : -EIO;
+	gxp_pm_set_thermal_limit(gxp, rate);
 
-	penultimate_throttle_state = thermal->gxp_num_states - 2;
-	/*
-	 * argument "power" is the maximum allowed power consumption in mW as
-	 * defined by the PID control loop. Check for the first state that is
-	 * less than or equal to the current allowed power. state_pwr_map is
-	 * descending, so lowest power consumption is last value in the array
-	 * return lowest state even if it consumes more power than allowed as
-	 * not all platforms can handle throttling below an active state
-	 */
-	for (i = penultimate_throttle_state; i >= 0; --i) {
-		if (power < state_pwr_map[i].power) {
-			*state = i + 1;
-			break;
-		}
-	}
 	return 0;
 }
 
-static struct thermal_cooling_device_ops gxp_cooling_ops = {
-	.get_max_state = gxp_get_max_state,
-	.get_cur_state = gxp_get_cur_state,
-	.set_cur_state = gxp_set_cur_state,
-	.get_requested_power = gxp_get_requested_power,
-	.state2power = gxp_state2power,
-	.power2state = gxp_power2state,
-};
-
-static void gxp_thermal_exit(struct gxp_thermal_manager *thermal)
-{
-	if (!IS_ERR_OR_NULL(thermal->cdev))
-		thermal_cooling_device_unregister(thermal->cdev);
-}
-
-static void devm_gxp_thermal_release(struct device *dev, void *res)
-{
-	struct gxp_thermal_manager *thermal = res;
-
-	gxp_thermal_exit(thermal);
-}
-
-static ssize_t
-user_vote_show(struct device *dev, struct device_attribute *attr, char *buf)
-{
-	struct thermal_cooling_device *cdev =
-			container_of(dev, struct thermal_cooling_device,
-				     device);
-	struct gxp_thermal_manager *cooling = cdev->devdata;
-
-	if (!cooling)
-		return -ENODEV;
-
-	return sysfs_emit(buf, "%lu\n", cooling->sysfs_req);
-}
-
-static ssize_t user_vote_store(struct device *dev,
-			       struct device_attribute *attr,
-			       const char *buf, size_t count)
-{
-	struct thermal_cooling_device *cdev =
-			container_of(dev, struct thermal_cooling_device,
-				     device);
-	struct gxp_thermal_manager *cooling = cdev->devdata;
-	int ret;
-	unsigned long state;
-
-	if (!cooling)
-		return -ENODEV;
-
-	ret = kstrtoul(buf, 0, &state);
-	if (ret)
-		return ret;
-
-	if (state >= cooling->gxp_num_states)
-		return -EINVAL;
-
-	mutex_lock(&cdev->lock);
-	cooling->sysfs_req = state;
-	cdev->updated = false;
-	mutex_unlock(&cdev->lock);
-	thermal_cdev_update(cdev);
-	return count;
-}
-
-static DEVICE_ATTR_RW(user_vote);
-
-static int
-gxp_thermal_cooling_register(struct gxp_thermal_manager *thermal, char *type)
+static int gxp_thermal_control(void *data, bool enable)
 {
-	struct device_node *cooling_node = NULL;
-
-	thermal->op_data = NULL;
-	thermal->gxp_num_states = ARRAY_SIZE(state_pwr_map);
-
-	mutex_init(&thermal->lock);
-	cooling_node = of_find_node_by_name(NULL, GXP_COOLING_NAME);
-
-	/* TODO: Change this to fatal error once dts change is merged */
-	if (!cooling_node)
-		dev_warn(thermal->gxp->dev, "failed to find cooling node\n");
-	/* Initialize the cooling state as 0, means "no cooling" */
-	thermal->cooling_state = 0;
-	thermal->cdev = thermal_of_cooling_device_register(
-		cooling_node, type, thermal, &gxp_cooling_ops);
-	if (IS_ERR(thermal->cdev))
-		return PTR_ERR(thermal->cdev);
-
-	return device_create_file(&thermal->cdev->device, &dev_attr_user_vote);
+	return -EOPNOTSUPP;
 }
 
-static int cooling_init(struct gxp_thermal_manager *thermal, struct device *dev)
+int gxp_thermal_init(struct gxp_dev *gxp)
 {
-	int err;
-	struct dentry *d;
+	const struct gcip_thermal_args args = {
+		.dev = gxp->dev,
+		.pm = gxp->power_mgr->pm,
+		.dentry = gxp->d_entry,
+		.node_name = GXP_COOLING_NAME,
+		.type = GXP_COOLING_NAME,
+		.data = gxp,
+		.get_rate = gxp_thermal_get_rate,
+		.set_rate = gxp_thermal_set_rate,
+		.control = gxp_thermal_control,
+	};
+	struct gcip_thermal *thermal;
+
+	if (gxp->thermal)
+		return -EEXIST;
+
+	thermal = gcip_thermal_create(&args);
+	if (IS_ERR(thermal))
+		return PTR_ERR(thermal);
+
+	gxp->thermal = thermal;
 
-	d = debugfs_create_dir("cooling", thermal->gxp->d_entry);
-	/* don't let debugfs creation failure abort the init procedure */
-	if (IS_ERR_OR_NULL(d))
-		dev_warn(dev, "failed to create debug fs for cooling");
-	thermal->cooling_root = d;
-
-	err = gxp_thermal_cooling_register(thermal, GXP_COOLING_NAME);
-	if (err) {
-		dev_err(dev, "failed to initialize external cooling\n");
-		gxp_thermal_exit(thermal);
-		return err;
-	}
 	return 0;
 }
 
-struct gxp_thermal_manager
-*gxp_thermal_init(struct gxp_dev *gxp)
+void gxp_thermal_exit(struct gxp_dev *gxp)
 {
-	struct device *dev = gxp->dev;
-	struct gxp_thermal_manager *thermal;
-	int err;
-
-	thermal = devres_alloc(devm_gxp_thermal_release, sizeof(*thermal),
-				GFP_KERNEL);
-	if (!thermal)
-		return ERR_PTR(-ENOMEM);
-
-	thermal->gxp = gxp;
-	err = cooling_init(thermal, dev);
-	if (err) {
-		devres_free(thermal);
-		return ERR_PTR(err);
-	}
-
-	devres_add(dev, thermal);
-	return thermal;
+	gcip_thermal_destroy(gxp->thermal);
+	gxp->thermal = NULL;
 }