[thirdparty/kernel/stable.git] / drivers / thermal / db8500_thermal.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * db8500_thermal.c - DB8500 Thermal Management Implementation
 *
 * Copyright (C) 2012 ST-Ericsson
 * Copyright (C) 2012 Linaro Ltd.
 *
 * Author: Hongbo Zhang <hongbo.zhang@linaro.com>
 */

#include <linux/cpu_cooling.h>
#include <linux/interrupt.h>
#include <linux/mfd/dbx500-prcmu.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_data/db8500_thermal.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/thermal.h>

#define PRCMU_DEFAULT_MEASURE_TIME	0xFFF
#define PRCMU_DEFAULT_LOW_TEMP		0

struct db8500_thermal_zone {
	struct thermal_zone_device *therm_dev;
	struct mutex th_lock;
	struct work_struct therm_work;
	struct db8500_thsens_platform_data *trip_tab;
	enum thermal_device_mode mode;
	enum thermal_trend trend;
	unsigned long cur_temp_pseudo;
	unsigned int cur_index;
};

/* Local function to check if thermal zone matches cooling devices */
static int db8500_thermal_match_cdev(struct thermal_cooling_device *cdev,
		struct db8500_trip_point *trip_point)
{
	int i;

	if (!strlen(cdev->type))
		return -EINVAL;

	for (i = 0; i < COOLING_DEV_MAX; i++) {
		if (!strcmp(trip_point->cdev_name[i], cdev->type))
			return 0;
	}

	return -ENODEV;
}

/* Callback to bind cooling device to thermal zone */
static int db8500_cdev_bind(struct thermal_zone_device *thermal,
		struct thermal_cooling_device *cdev)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	unsigned long max_state, upper, lower;
	int i, ret = -EINVAL;

	cdev->ops->get_max_state(cdev, &max_state);

	for (i = 0; i < ptrips->num_trips; i++) {
		if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
			continue;

		upper = lower = i > max_state ? max_state : i;

		ret = thermal_zone_bind_cooling_device(thermal, i, cdev,
			upper, lower, THERMAL_WEIGHT_DEFAULT);

		dev_info(&cdev->device, "%s bind to %d: %d-%s\n", cdev->type,
			i, ret, ret ? "fail" : "succeed");
	}

	return ret;
}

/* Callback to unbind cooling device from thermal zone */
static int db8500_cdev_unbind(struct thermal_zone_device *thermal,
		struct thermal_cooling_device *cdev)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	int i, ret = -EINVAL;

	for (i = 0; i < ptrips->num_trips; i++) {
		if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
			continue;

		ret = thermal_zone_unbind_cooling_device(thermal, i, cdev);

		dev_info(&cdev->device, "%s unbind from %d: %s\n", cdev->type,
			i, ret ? "fail" : "succeed");
	}

	return ret;
}

/* Callback to get current temperature */
static int db8500_sys_get_temp(struct thermal_zone_device *thermal, int *temp)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;

	/*
	 * TODO: There is no PRCMU interface to get temperature data currently,
	 * so a pseudo temperature is returned , it works for thermal framework
	 * and this will be fixed when the PRCMU interface is available.
	 */
	*temp = pzone->cur_temp_pseudo;

	return 0;
}

/* Callback to get temperature changing trend */
static int db8500_sys_get_trend(struct thermal_zone_device *thermal,
		int trip, enum thermal_trend *trend)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;

	*trend = pzone->trend;

	return 0;
}

/* Callback to get thermal zone mode */
static int db8500_sys_get_mode(struct thermal_zone_device *thermal,
		enum thermal_device_mode *mode)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;

	mutex_lock(&pzone->th_lock);
	*mode = pzone->mode;
	mutex_unlock(&pzone->th_lock);

	return 0;
}

/* Callback to set thermal zone mode */
static int db8500_sys_set_mode(struct thermal_zone_device *thermal,
		enum thermal_device_mode mode)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;

	mutex_lock(&pzone->th_lock);

	pzone->mode = mode;
	if (mode == THERMAL_DEVICE_ENABLED)
		schedule_work(&pzone->therm_work);

	mutex_unlock(&pzone->th_lock);

	return 0;
}

/* Callback to get trip point type */
static int db8500_sys_get_trip_type(struct thermal_zone_device *thermal,
		int trip, enum thermal_trip_type *type)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;

	if (trip >= ptrips->num_trips)
		return -EINVAL;

	*type = ptrips->trip_points[trip].type;

	return 0;
}

/* Callback to get trip point temperature */
static int db8500_sys_get_trip_temp(struct thermal_zone_device *thermal,
		int trip, int *temp)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;

	if (trip >= ptrips->num_trips)
		return -EINVAL;

	*temp = ptrips->trip_points[trip].temp;

	return 0;
}

/* Callback to get critical trip point temperature */
static int db8500_sys_get_crit_temp(struct thermal_zone_device *thermal,
		int *temp)
{
	struct db8500_thermal_zone *pzone = thermal->devdata;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	int i;

	for (i = ptrips->num_trips - 1; i > 0; i--) {
		if (ptrips->trip_points[i].type == THERMAL_TRIP_CRITICAL) {
			*temp = ptrips->trip_points[i].temp;
			return 0;
		}
	}

	return -EINVAL;
}

static struct thermal_zone_device_ops thdev_ops = {
	.bind = db8500_cdev_bind,
	.unbind = db8500_cdev_unbind,
	.get_temp = db8500_sys_get_temp,
	.get_trend = db8500_sys_get_trend,
	.get_mode = db8500_sys_get_mode,
	.set_mode = db8500_sys_set_mode,
	.get_trip_type = db8500_sys_get_trip_type,
	.get_trip_temp = db8500_sys_get_trip_temp,
	.get_crit_temp = db8500_sys_get_crit_temp,
};

static void db8500_thermal_update_config(struct db8500_thermal_zone *pzone,
		unsigned int idx, enum thermal_trend trend,
		unsigned long next_low, unsigned long next_high)
{
	prcmu_stop_temp_sense();

	pzone->cur_index = idx;
	pzone->cur_temp_pseudo = (next_low + next_high)/2;
	pzone->trend = trend;

	prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000));
	prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME);
}

static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data)
{
	struct db8500_thermal_zone *pzone = irq_data;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	unsigned int idx = pzone->cur_index;
	unsigned long next_low, next_high;

	if (unlikely(idx == 0))
		/* Meaningless for thermal management, ignoring it */
		return IRQ_HANDLED;

	if (idx == 1) {
		next_high = ptrips->trip_points[0].temp;
		next_low = PRCMU_DEFAULT_LOW_TEMP;
	} else {
		next_high = ptrips->trip_points[idx-1].temp;
		next_low = ptrips->trip_points[idx-2].temp;
	}
	idx -= 1;

	db8500_thermal_update_config(pzone, idx, THERMAL_TREND_DROPPING,
		next_low, next_high);

	dev_dbg(&pzone->therm_dev->device,
		"PRCMU set max %ld, min %ld\n", next_high, next_low);

	schedule_work(&pzone->therm_work);

	return IRQ_HANDLED;
}

static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data)
{
	struct db8500_thermal_zone *pzone = irq_data;
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	unsigned int idx = pzone->cur_index;
	unsigned long next_low, next_high;

	if (idx < ptrips->num_trips - 1) {
		next_high = ptrips->trip_points[idx+1].temp;
		next_low = ptrips->trip_points[idx].temp;
		idx += 1;

		db8500_thermal_update_config(pzone, idx, THERMAL_TREND_RAISING,
			next_low, next_high);

		dev_dbg(&pzone->therm_dev->device,
		"PRCMU set max %ld, min %ld\n", next_high, next_low);
	} else if (idx == ptrips->num_trips - 1)
		pzone->cur_temp_pseudo = ptrips->trip_points[idx].temp + 1;

	schedule_work(&pzone->therm_work);

	return IRQ_HANDLED;
}

static void db8500_thermal_work(struct work_struct *work)
{
	enum thermal_device_mode cur_mode;
	struct db8500_thermal_zone *pzone;

	pzone = container_of(work, struct db8500_thermal_zone, therm_work);

	mutex_lock(&pzone->th_lock);
	cur_mode = pzone->mode;
	mutex_unlock(&pzone->th_lock);

	if (cur_mode == THERMAL_DEVICE_DISABLED)
		return;

	thermal_zone_device_update(pzone->therm_dev, THERMAL_EVENT_UNSPECIFIED);
	dev_dbg(&pzone->therm_dev->device, "thermal work finished.\n");
}

#ifdef CONFIG_OF
static struct db8500_thsens_platform_data*
		db8500_thermal_parse_dt(struct platform_device *pdev)
{
	struct db8500_thsens_platform_data *ptrips;
	struct device_node *np = pdev->dev.of_node;
	char prop_name[32];
	const char *tmp_str;
	u32 tmp_data;
	int i, j;

	ptrips = devm_kzalloc(&pdev->dev, sizeof(*ptrips), GFP_KERNEL);
	if (!ptrips)
		return NULL;

	if (of_property_read_u32(np, "num-trips", &tmp_data))
		goto err_parse_dt;

	if (tmp_data > THERMAL_MAX_TRIPS)
		goto err_parse_dt;

	ptrips->num_trips = tmp_data;

	for (i = 0; i < ptrips->num_trips; i++) {
		sprintf(prop_name, "trip%d-temp", i);
		if (of_property_read_u32(np, prop_name, &tmp_data))
			goto err_parse_dt;

		ptrips->trip_points[i].temp = tmp_data;

		sprintf(prop_name, "trip%d-type", i);
		if (of_property_read_string(np, prop_name, &tmp_str))
			goto err_parse_dt;

		if (!strcmp(tmp_str, "active"))
			ptrips->trip_points[i].type = THERMAL_TRIP_ACTIVE;
		else if (!strcmp(tmp_str, "passive"))
			ptrips->trip_points[i].type = THERMAL_TRIP_PASSIVE;
		else if (!strcmp(tmp_str, "hot"))
			ptrips->trip_points[i].type = THERMAL_TRIP_HOT;
		else if (!strcmp(tmp_str, "critical"))
			ptrips->trip_points[i].type = THERMAL_TRIP_CRITICAL;
		else
			goto err_parse_dt;

		sprintf(prop_name, "trip%d-cdev-num", i);
		if (of_property_read_u32(np, prop_name, &tmp_data))
			goto err_parse_dt;

		if (tmp_data > COOLING_DEV_MAX)
			goto err_parse_dt;

		for (j = 0; j < tmp_data; j++) {
			sprintf(prop_name, "trip%d-cdev-name%d", i, j);
			if (of_property_read_string(np, prop_name, &tmp_str))
				goto err_parse_dt;

			if (strlen(tmp_str) >= THERMAL_NAME_LENGTH)
				goto err_parse_dt;

			strcpy(ptrips->trip_points[i].cdev_name[j], tmp_str);
		}
	}
	return ptrips;

err_parse_dt:
	dev_err(&pdev->dev, "Parsing device tree data error.\n");
	return NULL;
}
#else
static inline struct db8500_thsens_platform_data*
		db8500_thermal_parse_dt(struct platform_device *pdev)
{
	return NULL;
}
#endif

static int db8500_thermal_probe(struct platform_device *pdev)
{
	struct db8500_thermal_zone *pzone = NULL;
	struct db8500_thsens_platform_data *ptrips = NULL;
	struct device_node *np = pdev->dev.of_node;
	int low_irq, high_irq, ret = 0;
	unsigned long dft_low, dft_high;

	if (np)
		ptrips = db8500_thermal_parse_dt(pdev);
	else
		ptrips = dev_get_platdata(&pdev->dev);

	if (!ptrips)
		return -EINVAL;

	pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL);
	if (!pzone)
		return -ENOMEM;

	mutex_init(&pzone->th_lock);
	mutex_lock(&pzone->th_lock);

	pzone->mode = THERMAL_DEVICE_DISABLED;
	pzone->trip_tab = ptrips;

	INIT_WORK(&pzone->therm_work, db8500_thermal_work);

	low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW");
	if (low_irq < 0) {
		dev_err(&pdev->dev, "Get IRQ_HOTMON_LOW failed.\n");
		ret = low_irq;
		goto out_unlock;
	}

	ret = devm_request_threaded_irq(&pdev->dev, low_irq, NULL,
		prcmu_low_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
		"dbx500_temp_low", pzone);
	if (ret < 0) {
		dev_err(&pdev->dev, "Failed to allocate temp low irq.\n");
		goto out_unlock;
	}

	high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH");
	if (high_irq < 0) {
		dev_err(&pdev->dev, "Get IRQ_HOTMON_HIGH failed.\n");
		ret = high_irq;
		goto out_unlock;
	}

	ret = devm_request_threaded_irq(&pdev->dev, high_irq, NULL,
		prcmu_high_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT,
		"dbx500_temp_high", pzone);
	if (ret < 0) {
		dev_err(&pdev->dev, "Failed to allocate temp high irq.\n");
		goto out_unlock;
	}

	pzone->therm_dev = thermal_zone_device_register("db8500_thermal_zone",
		ptrips->num_trips, 0, pzone, &thdev_ops, NULL, 0, 0);

	if (IS_ERR(pzone->therm_dev)) {
		dev_err(&pdev->dev, "Register thermal zone device failed.\n");
		ret = PTR_ERR(pzone->therm_dev);
		goto out_unlock;
	}
	dev_info(&pdev->dev, "Thermal zone device registered.\n");

	dft_low = PRCMU_DEFAULT_LOW_TEMP;
	dft_high = ptrips->trip_points[0].temp;

	db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
		dft_low, dft_high);

	platform_set_drvdata(pdev, pzone);
	pzone->mode = THERMAL_DEVICE_ENABLED;

out_unlock:
	mutex_unlock(&pzone->th_lock);

	return ret;
}

static int db8500_thermal_remove(struct platform_device *pdev)
{
	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);

	thermal_zone_device_unregister(pzone->therm_dev);
	cancel_work_sync(&pzone->therm_work);
	mutex_destroy(&pzone->th_lock);

	return 0;
}

static int db8500_thermal_suspend(struct platform_device *pdev,
		pm_message_t state)
{
	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);

	flush_work(&pzone->therm_work);
	prcmu_stop_temp_sense();

	return 0;
}

static int db8500_thermal_resume(struct platform_device *pdev)
{
	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	unsigned long dft_low, dft_high;

	dft_low = PRCMU_DEFAULT_LOW_TEMP;
	dft_high = ptrips->trip_points[0].temp;

	db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
		dft_low, dft_high);

	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id db8500_thermal_match[] = {
	{ .compatible = "stericsson,db8500-thermal" },
	{},
};
MODULE_DEVICE_TABLE(of, db8500_thermal_match);
#endif

static struct platform_driver db8500_thermal_driver = {
	.driver = {
		.name = "db8500-thermal",
		.of_match_table = of_match_ptr(db8500_thermal_match),
	},
	.probe = db8500_thermal_probe,
	.suspend = db8500_thermal_suspend,
	.resume = db8500_thermal_resume,
	.remove = db8500_thermal_remove,
};

module_platform_driver(db8500_thermal_driver);

MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>");
MODULE_DESCRIPTION("DB8500 thermal driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
c942fddf	1	// SPDX-License-Identifier: GPL-2.0-or-later
aa1acb04	2	/*
	3	* db8500_thermal.c - DB8500 Thermal Management Implementation
	4	*
	5	* Copyright (C) 2012 ST-Ericsson
	6	* Copyright (C) 2012 Linaro Ltd.
	7	*
	8	* Author: Hongbo Zhang <hongbo.zhang@linaro.com>
aa1acb04	9	*/
	10
	11	#include <linux/cpu_cooling.h>
	12	#include <linux/interrupt.h>
	13	#include <linux/mfd/dbx500-prcmu.h>
	14	#include <linux/module.h>
	15	#include <linux/of.h>
	16	#include <linux/platform_data/db8500_thermal.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/slab.h>
	19	#include <linux/thermal.h>
	20
	21	#define PRCMU_DEFAULT_MEASURE_TIME 0xFFF
	22	#define PRCMU_DEFAULT_LOW_TEMP 0
	23
	24	struct db8500_thermal_zone {
	25	struct thermal_zone_device *therm_dev;
	26	struct mutex th_lock;
	27	struct work_struct therm_work;
	28	struct db8500_thsens_platform_data *trip_tab;
	29	enum thermal_device_mode mode;
	30	enum thermal_trend trend;
	31	unsigned long cur_temp_pseudo;
	32	unsigned int cur_index;
	33	};
	34
	35	/* Local function to check if thermal zone matches cooling devices */
	36	static int db8500_thermal_match_cdev(struct thermal_cooling_device *cdev,
	37	struct db8500_trip_point *trip_point)
	38	{
	39	int i;
	40
	41	if (!strlen(cdev->type))
	42	return -EINVAL;
	43
	44	for (i = 0; i < COOLING_DEV_MAX; i++) {
	45	if (!strcmp(trip_point->cdev_name[i], cdev->type))
	46	return 0;
	47	}
	48
	49	return -ENODEV;
	50	}
	51
	52	/* Callback to bind cooling device to thermal zone */
	53	static int db8500_cdev_bind(struct thermal_zone_device *thermal,
	54	struct thermal_cooling_device *cdev)
	55	{
	56	struct db8500_thermal_zone *pzone = thermal->devdata;
	57	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	58	unsigned long max_state, upper, lower;
	59	int i, ret = -EINVAL;
	60
	61	cdev->ops->get_max_state(cdev, &max_state);
	62
	63	for (i = 0; i < ptrips->num_trips; i++) {
	64	if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
	65	continue;
	66
	67	upper = lower = i > max_state ? max_state : i;
	68
	69	ret = thermal_zone_bind_cooling_device(thermal, i, cdev,
6cd9e9f6	70	upper, lower, THERMAL_WEIGHT_DEFAULT);
aa1acb04	71
	72	dev_info(&cdev->device, "%s bind to %d: %d-%s\n", cdev->type,
	73	i, ret, ret ? "fail" : "succeed");
	74	}
	75
	76	return ret;
	77	}
	78
	79	/* Callback to unbind cooling device from thermal zone */
	80	static int db8500_cdev_unbind(struct thermal_zone_device *thermal,
	81	struct thermal_cooling_device *cdev)
	82	{
	83	struct db8500_thermal_zone *pzone = thermal->devdata;
	84	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	85	int i, ret = -EINVAL;
	86
	87	for (i = 0; i < ptrips->num_trips; i++) {
	88	if (db8500_thermal_match_cdev(cdev, &ptrips->trip_points[i]))
	89	continue;
	90
	91	ret = thermal_zone_unbind_cooling_device(thermal, i, cdev);
	92
	93	dev_info(&cdev->device, "%s unbind from %d: %s\n", cdev->type,
	94	i, ret ? "fail" : "succeed");
	95	}
	96
	97	return ret;
	98	}
	99
	100	/* Callback to get current temperature */
17e8351a	101	static int db8500_sys_get_temp(struct thermal_zone_device thermal, int temp)
aa1acb04	102	{
	103	struct db8500_thermal_zone *pzone = thermal->devdata;
	104
	105	/*
	106	* TODO: There is no PRCMU interface to get temperature data currently,
	107	* so a pseudo temperature is returned , it works for thermal framework
	108	* and this will be fixed when the PRCMU interface is available.
	109	*/
	110	*temp = pzone->cur_temp_pseudo;
	111
	112	return 0;
	113	}
	114
	115	/* Callback to get temperature changing trend */
	116	static int db8500_sys_get_trend(struct thermal_zone_device *thermal,
	117	int trip, enum thermal_trend *trend)
	118	{
	119	struct db8500_thermal_zone *pzone = thermal->devdata;
	120
	121	*trend = pzone->trend;
	122
	123	return 0;
	124	}
	125
	126	/* Callback to get thermal zone mode */
	127	static int db8500_sys_get_mode(struct thermal_zone_device *thermal,
	128	enum thermal_device_mode *mode)
	129	{
	130	struct db8500_thermal_zone *pzone = thermal->devdata;
	131
	132	mutex_lock(&pzone->th_lock);
	133	*mode = pzone->mode;
	134	mutex_unlock(&pzone->th_lock);
	135
	136	return 0;
	137	}
	138
	139	/* Callback to set thermal zone mode */
	140	static int db8500_sys_set_mode(struct thermal_zone_device *thermal,
	141	enum thermal_device_mode mode)
	142	{
	143	struct db8500_thermal_zone *pzone = thermal->devdata;
	144
	145	mutex_lock(&pzone->th_lock);
	146
	147	pzone->mode = mode;
	148	if (mode == THERMAL_DEVICE_ENABLED)
	149	schedule_work(&pzone->therm_work);
	150
	151	mutex_unlock(&pzone->th_lock);
	152
	153	return 0;
	154	}
	155
	156	/* Callback to get trip point type */
	157	static int db8500_sys_get_trip_type(struct thermal_zone_device *thermal,
	158	int trip, enum thermal_trip_type *type)
	159	{
	160	struct db8500_thermal_zone *pzone = thermal->devdata;
	161	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	162
	163	if (trip >= ptrips->num_trips)
	164	return -EINVAL;
	165
166	*type = ptrips->trip_points[trip].type;
167
168	return 0;
169	}
170
171	/* Callback to get trip point temperature */
172	static int db8500_sys_get_trip_temp(struct thermal_zone_device *thermal,
17e8351a	173	int trip, int *temp)
aa1acb04	174	{
	175	struct db8500_thermal_zone *pzone = thermal->devdata;
	176	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	177
	178	if (trip >= ptrips->num_trips)
	179	return -EINVAL;
	180
	181	*temp = ptrips->trip_points[trip].temp;
	182
	183	return 0;
	184	}
	185
	186	/* Callback to get critical trip point temperature */
	187	static int db8500_sys_get_crit_temp(struct thermal_zone_device *thermal,
17e8351a	188	int *temp)
aa1acb04	189	{
	190	struct db8500_thermal_zone *pzone = thermal->devdata;
	191	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	192	int i;
	193
	194	for (i = ptrips->num_trips - 1; i > 0; i--) {
	195	if (ptrips->trip_points[i].type == THERMAL_TRIP_CRITICAL) {
	196	*temp = ptrips->trip_points[i].temp;
	197	return 0;
	198	}
	199	}
	200
	201	return -EINVAL;
	202	}
	203
	204	static struct thermal_zone_device_ops thdev_ops = {
	205	.bind = db8500_cdev_bind,
	206	.unbind = db8500_cdev_unbind,
	207	.get_temp = db8500_sys_get_temp,
	208	.get_trend = db8500_sys_get_trend,
	209	.get_mode = db8500_sys_get_mode,
	210	.set_mode = db8500_sys_set_mode,
	211	.get_trip_type = db8500_sys_get_trip_type,
	212	.get_trip_temp = db8500_sys_get_trip_temp,
	213	.get_crit_temp = db8500_sys_get_crit_temp,
	214	};
	215
	216	static void db8500_thermal_update_config(struct db8500_thermal_zone *pzone,
	217	unsigned int idx, enum thermal_trend trend,
	218	unsigned long next_low, unsigned long next_high)
	219	{
	220	prcmu_stop_temp_sense();
	221
	222	pzone->cur_index = idx;
	223	pzone->cur_temp_pseudo = (next_low + next_high)/2;
	224	pzone->trend = trend;
	225
	226	prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000));
	227	prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME);
	228	}
	229
	230	static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data)
	231	{
	232	struct db8500_thermal_zone *pzone = irq_data;
	233	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	234	unsigned int idx = pzone->cur_index;
	235	unsigned long next_low, next_high;
	236
	237	if (unlikely(idx == 0))
	238	/* Meaningless for thermal management, ignoring it */
	239	return IRQ_HANDLED;
	240
	241	if (idx == 1) {
	242	next_high = ptrips->trip_points[0].temp;
	243	next_low = PRCMU_DEFAULT_LOW_TEMP;
	244	} else {
	245	next_high = ptrips->trip_points[idx-1].temp;
	246	next_low = ptrips->trip_points[idx-2].temp;
	247	}
	248	idx -= 1;
	249
	250	db8500_thermal_update_config(pzone, idx, THERMAL_TREND_DROPPING,
	251	next_low, next_high);
	252
253	dev_dbg(&pzone->therm_dev->device,
254	"PRCMU set max %ld, min %ld\n", next_high, next_low);
255
256	schedule_work(&pzone->therm_work);
257
258	return IRQ_HANDLED;
259	}
260
261	static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data)
262	{
263	struct db8500_thermal_zone *pzone = irq_data;
264	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
265	unsigned int idx = pzone->cur_index;
266	unsigned long next_low, next_high;
267
268	if (idx < ptrips->num_trips - 1) {
269	next_high = ptrips->trip_points[idx+1].temp;
270	next_low = ptrips->trip_points[idx].temp;
271	idx += 1;
272
273	db8500_thermal_update_config(pzone, idx, THERMAL_TREND_RAISING,
274	next_low, next_high);
275
276	dev_dbg(&pzone->therm_dev->device,
277	"PRCMU set max %ld, min %ld\n", next_high, next_low);
278	} else if (idx == ptrips->num_trips - 1)
279	pzone->cur_temp_pseudo = ptrips->trip_points[idx].temp + 1;
280
281	schedule_work(&pzone->therm_work);
282
283	return IRQ_HANDLED;
284	}
285
286	static void db8500_thermal_work(struct work_struct *work)
287	{
288	enum thermal_device_mode cur_mode;
289	struct db8500_thermal_zone *pzone;
290
291	pzone = container_of(work, struct db8500_thermal_zone, therm_work);
292
293	mutex_lock(&pzone->th_lock);
294	cur_mode = pzone->mode;
295	mutex_unlock(&pzone->th_lock);
296
297	if (cur_mode == THERMAL_DEVICE_DISABLED)
298	return;
299
0e70f466	300	thermal_zone_device_update(pzone->therm_dev, THERMAL_EVENT_UNSPECIFIED);
aa1acb04	301	dev_dbg(&pzone->therm_dev->device, "thermal work finished.\n");
	302	}
	303
	304	#ifdef CONFIG_OF
	305	static struct db8500_thsens_platform_data*
	306	db8500_thermal_parse_dt(struct platform_device *pdev)
	307	{
	308	struct db8500_thsens_platform_data *ptrips;
	309	struct device_node *np = pdev->dev.of_node;
	310	char prop_name[32];
	311	const char *tmp_str;
	312	u32 tmp_data;
	313	int i, j;
	314
	315	ptrips = devm_kzalloc(&pdev->dev, sizeof(*ptrips), GFP_KERNEL);
	316	if (!ptrips)
	317	return NULL;
	318
	319	if (of_property_read_u32(np, "num-trips", &tmp_data))
	320	goto err_parse_dt;
	321
	322	if (tmp_data > THERMAL_MAX_TRIPS)
	323	goto err_parse_dt;
	324
	325	ptrips->num_trips = tmp_data;
	326
	327	for (i = 0; i < ptrips->num_trips; i++) {
	328	sprintf(prop_name, "trip%d-temp", i);
	329	if (of_property_read_u32(np, prop_name, &tmp_data))
	330	goto err_parse_dt;
	331
	332	ptrips->trip_points[i].temp = tmp_data;
	333
	334	sprintf(prop_name, "trip%d-type", i);
	335	if (of_property_read_string(np, prop_name, &tmp_str))
	336	goto err_parse_dt;
	337
	338	if (!strcmp(tmp_str, "active"))
	339	ptrips->trip_points[i].type = THERMAL_TRIP_ACTIVE;
	340	else if (!strcmp(tmp_str, "passive"))
	341	ptrips->trip_points[i].type = THERMAL_TRIP_PASSIVE;
	342	else if (!strcmp(tmp_str, "hot"))
	343	ptrips->trip_points[i].type = THERMAL_TRIP_HOT;
	344	else if (!strcmp(tmp_str, "critical"))
	345	ptrips->trip_points[i].type = THERMAL_TRIP_CRITICAL;
	346	else
	347	goto err_parse_dt;
	348
	349	sprintf(prop_name, "trip%d-cdev-num", i);
	350	if (of_property_read_u32(np, prop_name, &tmp_data))
	351	goto err_parse_dt;
	352
	353	if (tmp_data > COOLING_DEV_MAX)
	354	goto err_parse_dt;
	355
	356	for (j = 0; j < tmp_data; j++) {
	357	sprintf(prop_name, "trip%d-cdev-name%d", i, j);
	358	if (of_property_read_string(np, prop_name, &tmp_str))
	359	goto err_parse_dt;
	360
	361	if (strlen(tmp_str) >= THERMAL_NAME_LENGTH)
	362	goto err_parse_dt;
	363
	364	strcpy(ptrips->trip_points[i].cdev_name[j], tmp_str);
365	}
366	}
367	return ptrips;
368
369	err_parse_dt:
370	dev_err(&pdev->dev, "Parsing device tree data error.\n");
371	return NULL;
372	}
373	#else
374	static inline struct db8500_thsens_platform_data*
375	db8500_thermal_parse_dt(struct platform_device *pdev)
376	{
377	return NULL;
378	}
379	#endif
380
381	static int db8500_thermal_probe(struct platform_device *pdev)
382	{
383	struct db8500_thermal_zone *pzone = NULL;
384	struct db8500_thsens_platform_data *ptrips = NULL;
385	struct device_node *np = pdev->dev.of_node;
386	int low_irq, high_irq, ret = 0;
387	unsigned long dft_low, dft_high;
388
389	if (np)
390	ptrips = db8500_thermal_parse_dt(pdev);
391	else
392	ptrips = dev_get_platdata(&pdev->dev);
393
394	if (!ptrips)
395	return -EINVAL;
396
397	pzone = devm_kzalloc(&pdev->dev, sizeof(*pzone), GFP_KERNEL);
398	if (!pzone)
399	return -ENOMEM;
400
401	mutex_init(&pzone->th_lock);
402	mutex_lock(&pzone->th_lock);
403
404	pzone->mode = THERMAL_DEVICE_DISABLED;
405	pzone->trip_tab = ptrips;
406
407	INIT_WORK(&pzone->therm_work, db8500_thermal_work);
408
409	low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW");
410	if (low_irq < 0) {
411	dev_err(&pdev->dev, "Get IRQ_HOTMON_LOW failed.\n");
4c7fa83a AL	412	ret = low_irq;
4c7fa83a AL	413	goto out_unlock;
aa1acb04	414	}
	415
	416	ret = devm_request_threaded_irq(&pdev->dev, low_irq, NULL,
	417	prcmu_low_irq_handler, IRQF_NO_SUSPEND \| IRQF_ONESHOT,
	418	"dbx500_temp_low", pzone);
	419	if (ret < 0) {
	420	dev_err(&pdev->dev, "Failed to allocate temp low irq.\n");
4c7fa83a	421	goto out_unlock;
aa1acb04	422	}
	423
	424	high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH");
	425	if (high_irq < 0) {
	426	dev_err(&pdev->dev, "Get IRQ_HOTMON_HIGH failed.\n");
4c7fa83a AL	427	ret = high_irq;
4c7fa83a AL	428	goto out_unlock;
aa1acb04	429	}
	430
	431	ret = devm_request_threaded_irq(&pdev->dev, high_irq, NULL,
	432	prcmu_high_irq_handler, IRQF_NO_SUSPEND \| IRQF_ONESHOT,
	433	"dbx500_temp_high", pzone);
	434	if (ret < 0) {
	435	dev_err(&pdev->dev, "Failed to allocate temp high irq.\n");
4c7fa83a	436	goto out_unlock;
aa1acb04	437	}
	438
	439	pzone->therm_dev = thermal_zone_device_register("db8500_thermal_zone",
	440	ptrips->num_trips, 0, pzone, &thdev_ops, NULL, 0, 0);
	441
f534e9bf	442	if (IS_ERR(pzone->therm_dev)) {
aa1acb04	443	dev_err(&pdev->dev, "Register thermal zone device failed.\n");
4c7fa83a AL	444	ret = PTR_ERR(pzone->therm_dev);
4c7fa83a AL	445	goto out_unlock;
aa1acb04	446	}
	447	dev_info(&pdev->dev, "Thermal zone device registered.\n");
	448
	449	dft_low = PRCMU_DEFAULT_LOW_TEMP;
	450	dft_high = ptrips->trip_points[0].temp;
	451
	452	db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
	453	dft_low, dft_high);
	454
	455	platform_set_drvdata(pdev, pzone);
	456	pzone->mode = THERMAL_DEVICE_ENABLED;
4c7fa83a AL	457
4c7fa83a AL	458	out_unlock:
aa1acb04	459	mutex_unlock(&pzone->th_lock);
aa1acb04	460
4c7fa83a	461	return ret;
aa1acb04	462	}
	463
	464	static int db8500_thermal_remove(struct platform_device *pdev)
	465	{
	466	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
	467
	468	thermal_zone_device_unregister(pzone->therm_dev);
	469	cancel_work_sync(&pzone->therm_work);
	470	mutex_destroy(&pzone->th_lock);
	471
	472	return 0;
	473	}
	474
	475	static int db8500_thermal_suspend(struct platform_device *pdev,
	476	pm_message_t state)
	477	{
	478	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
	479
	480	flush_work(&pzone->therm_work);
	481	prcmu_stop_temp_sense();
	482
	483	return 0;
	484	}
	485
	486	static int db8500_thermal_resume(struct platform_device *pdev)
	487	{
	488	struct db8500_thermal_zone *pzone = platform_get_drvdata(pdev);
	489	struct db8500_thsens_platform_data *ptrips = pzone->trip_tab;
	490	unsigned long dft_low, dft_high;
	491
	492	dft_low = PRCMU_DEFAULT_LOW_TEMP;
	493	dft_high = ptrips->trip_points[0].temp;
	494
	495	db8500_thermal_update_config(pzone, 0, THERMAL_TREND_STABLE,
	496	dft_low, dft_high);
	497
	498	return 0;
	499	}
	500
	501	#ifdef CONFIG_OF
	502	static const struct of_device_id db8500_thermal_match[] = {
	503	{ .compatible = "stericsson,db8500-thermal" },
	504	{},
	505	};
8093a116	506	MODULE_DEVICE_TABLE(of, db8500_thermal_match);
aa1acb04	507	#endif
	508
	509	static struct platform_driver db8500_thermal_driver = {
	510	.driver = {
aa1acb04	511	.name = "db8500-thermal",
c3136376	512	.of_match_table = of_match_ptr(db8500_thermal_match),
aa1acb04	513	},
	514	.probe = db8500_thermal_probe,
	515	.suspend = db8500_thermal_suspend,
	516	.resume = db8500_thermal_resume,
	517	.remove = db8500_thermal_remove,
	518	};
	519
	520	module_platform_driver(db8500_thermal_driver);
	521
	522	MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>");
	523	MODULE_DESCRIPTION("DB8500 thermal driver");
	524	MODULE_LICENSE("GPL");