Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ca3ff561 authored by Ram Chandrasekar's avatar Ram Chandrasekar
Browse files

drivers: thermal: pe_sensor: Add Policy Engine sensor 



Add Policy Engine(PE) sensor recommendation as a sensor with thermal
framework. PE will recommend a mitigation level based on the operating
level of CX/MX clients. Registering this recommendations as sensor enables
the user to provide thermal zone configuration to mitigate cooling devices
for different policy engine recommendations.

Change-Id: I65e1a8baad62957482daca493987d6cd51eee3ef
Signed-off-by: default avatarRam Chandrasekar <rkumbako@codeaurora.org>
parent bbc7f2d3

drivers/thermal/qcom/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -100,3 +100,12 @@ config QTI_CPU_VOLTAGE_COOLING_DEVICE 
	    cluster to be mitigated together based on the voltages. This will

	    decrease or increase the voltages in a cluster based on thermal

	    conditions.



config QTI_POLICY_ENGINE_SENSOR

	tristate "QTI Policy Engine Sensor device"

	depends on THERMAL_OF && QTI_THERMAL

	help

	    This enables the QTI Policy Engine sensor device. This driver will

	    register the policy engine recommendation with thermal framework as

	    a sensor. This will enable to provide configuration to mitigate

	    cooling devices when a recommendation is sent from hardware.

drivers/thermal/qcom/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -17,3 +17,4 @@ obj-$(CONFIG_QTI_BCL_PMIC5) += bcl_pmic5.o 
obj-$(CONFIG_QTI_BCL_SOC_DRIVER) += bcl_soc.o

obj-$(CONFIG_QTI_THERMAL_LIMITS_DCVS) += msm_lmh_dcvs.o

obj-$(CONFIG_QTI_CPU_VOLTAGE_COOLING_DEVICE) += cpu_voltage_cooling.o

obj-$(CONFIG_QTI_POLICY_ENGINE_SENSOR) += policy_engine.o

drivers/thermal/qcom/policy_engine.c

0 → 100644
+184 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2020, The Linux Foundation. All rights reserved.

 */



#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/thermal.h>

#include <linux/err.h>

#include <linux/slab.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/interrupt.h>



#include "../thermal_core.h"



#define PE_SENS_DRIVER		"policy-engine-sensor"

#define PE_INT_ENABLE_OFFSET	0x530

#define PE_STATUS_OFFSET	0x590

#define PE_INT_STATUS_OFFSET	0x620

#define PE_INTR_CFG		0x11000

#define PE_INTR_CLEAR		0x11111

#define PE_READ_MITIGATION_IDX(val) ((val >> 16) & 0x1F)



struct pe_sensor_data {

	struct device			*dev;

	struct thermal_zone_device	*tz_dev;

	int32_t				high_thresh;

	int32_t				low_thresh;

	int32_t				irq_num;

	void __iomem			*regmap;

	struct mutex			mutex;

};



static int fetch_mitigation_table_idx(struct pe_sensor_data *pe_sens, int *temp)

{

	u32 data = 0;



	data = readl_relaxed(pe_sens->regmap + PE_STATUS_OFFSET);

	*temp = PE_READ_MITIGATION_IDX(data);

	dev_dbg(pe_sens->dev, "PE data:%d index:%d\n", data, *temp);



	return 0;

}



static int pe_sensor_read(void *data, int *temp)

{

	struct pe_sensor_data *pe_sens = (struct pe_sensor_data *)data;



	return fetch_mitigation_table_idx(pe_sens, temp);

}



static int pe_sensor_set_trips(void *data, int low, int high)

{

	struct pe_sensor_data *pe_sens = (struct pe_sensor_data *)data;



	mutex_lock(&pe_sens->mutex);

	if (pe_sens->high_thresh == high &&

		pe_sens->low_thresh == low)

		goto unlock_exit;

	pe_sens->high_thresh = high;

	pe_sens->low_thresh = low;

	dev_dbg(pe_sens->dev, "PE rail set trip. high:%d low:%d\n",

				high, low);



unlock_exit:

	mutex_unlock(&pe_sens->mutex);

	return 0;

}



static struct thermal_zone_of_device_ops pe_sensor_ops = {

	.get_temp = pe_sensor_read,

	.set_trips = pe_sensor_set_trips,

};



static irqreturn_t pe_handle_irq(int irq, void *data)

{

	struct pe_sensor_data *pe_sens = (struct pe_sensor_data *)data;

	int val = 0, ret = 0;



	ret = fetch_mitigation_table_idx(pe_sens, &val);

	if (ret)

		return IRQ_HANDLED;



	mutex_lock(&pe_sens->mutex);

	dev_dbg(pe_sens->dev, "Policy Engine interrupt fired value:%d\n", val);

	if (pe_sens->tz_dev && (val >= pe_sens->high_thresh ||

			val <= pe_sens->low_thresh)) {

		mutex_unlock(&pe_sens->mutex);

		of_thermal_handle_trip_temp(pe_sens->dev, pe_sens->tz_dev, val);

	} else

		mutex_unlock(&pe_sens->mutex);

	writel_relaxed(PE_INTR_CLEAR, pe_sens->regmap + PE_INT_STATUS_OFFSET);



	return IRQ_HANDLED;

}



static int pe_sens_device_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	int ret = 0;

	struct pe_sensor_data *pe_sens;

	struct resource *res;



	pe_sens = devm_kzalloc(dev, sizeof(*pe_sens), GFP_KERNEL);

	if (!pe_sens)

		return -ENOMEM;

	pe_sens->dev = dev;

	pe_sens->high_thresh = INT_MAX;

	pe_sens->low_thresh = INT_MIN;

	mutex_init(&pe_sens->mutex);



	dev_set_drvdata(dev, pe_sens);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {

		dev_err(dev, "Couldn't get MEM resource\n");

		return -EINVAL;

	}

	dev_dbg(dev, "pe@0x%x size:%d\n", res->start,

			resource_size(res));



	pe_sens->regmap = devm_ioremap_resource(dev, res);

	if (!pe_sens->regmap) {

		dev_err(dev, "Couldn't get regmap\n");

		return -EINVAL;

	}



	pe_sens->irq_num = platform_get_irq(pdev, 0);

	if (pe_sens->irq_num < 0) {

		dev_err(dev, "Couldn't get irq number\n");

		return pe_sens->irq_num;

	}

	pe_sens->tz_dev = devm_thermal_zone_of_sensor_register(

				dev, 0, pe_sens, &pe_sensor_ops);

	if (IS_ERR_OR_NULL(pe_sens->tz_dev)) {

		ret = PTR_ERR(pe_sens->tz_dev);

		if (ret != -ENODEV)

			dev_err(dev, "sensor register failed. ret:%d\n", ret);

		pe_sens->tz_dev = NULL;

		return ret;

	}

	writel_relaxed(PE_INTR_CFG, pe_sens->regmap + PE_INT_ENABLE_OFFSET);

	writel_relaxed(PE_INTR_CLEAR, pe_sens->regmap + PE_INT_STATUS_OFFSET);

	ret = devm_request_threaded_irq(dev, pe_sens->irq_num, NULL,

				pe_handle_irq,

				IRQF_TRIGGER_HIGH | IRQF_ONESHOT,

				dev_name(dev), pe_sens);

	if (ret) {

		dev_err(dev, "Couldn't get irq registered\n");

		thermal_zone_of_sensor_unregister(pe_sens->dev,

				pe_sens->tz_dev);

		return ret;

	}

	dev_dbg(dev, "PE sensor register success\n");



	return 0;

}



static int pe_sens_device_remove(struct platform_device *pdev)

{

	struct pe_sensor_data *pe_sens =

		(struct pe_sensor_data *)dev_get_drvdata(&pdev->dev);



	thermal_zone_of_sensor_unregister(pe_sens->dev, pe_sens->tz_dev);



	return 0;

}



static const struct of_device_id pe_sens_device_match[] = {

	{.compatible = "qcom,policy-engine"},

	{}

};



static struct platform_driver pe_sens_device_driver = {

	.probe          = pe_sens_device_probe,

	.remove         = pe_sens_device_remove,

	.driver         = {

		.name   = PE_SENS_DRIVER,

		.of_match_table = pe_sens_device_match,

	},

};



module_platform_driver(pe_sens_device_driver);

MODULE_LICENSE("GPL v2");