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

Commit 7961b130 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

ANDROID: revert all remaining hisi_thermal.c changes 



hisi_thermal.c changes do not belong in the android-common tree, as
there is a separate tree just for this board.  Revert the remaining
changes here as it is causing build and merge issues.

Reported-by: default avatarTodd Kjos <tkjos@google.com>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent e525d2cf

drivers/thermal/hisi_thermal.c

+137 −331
Original line number Diff line number Diff line
@@ -23,103 +23,79 @@ 
#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/io.h>

#include <linux/of_device.h>



#include "thermal_core.h"



#define HI6220_TEMP0_LAG			(0x0)

#define HI6220_TEMP0_TH				(0x4)

#define HI6220_TEMP0_RST_TH			(0x8)

#define HI6220_TEMP0_CFG			(0xC)

#define HI6220_TEMP0_CFG_SS_MSK			(0xF000)

#define HI6220_TEMP0_CFG_HDAK_MSK		(0x30)

#define HI6220_TEMP0_EN				(0x10)

#define HI6220_TEMP0_INT_EN			(0x14)

#define HI6220_TEMP0_INT_CLR			(0x18)

#define HI6220_TEMP0_RST_MSK			(0x1C)

#define HI6220_TEMP0_VALUE			(0x28)



#define HI3660_OFFSET(chan)		((chan) * 0x40)

#define HI3660_TEMP(chan)		(HI3660_OFFSET(chan) + 0x1C)

#define HI3660_TH(chan)			(HI3660_OFFSET(chan) + 0x20)

#define HI3660_LAG(chan)		(HI3660_OFFSET(chan) + 0x28)

#define HI3660_INT_EN(chan)		(HI3660_OFFSET(chan) + 0x2C)

#define HI3660_INT_CLR(chan)		(HI3660_OFFSET(chan) + 0x30)



#define HI6220_TEMP_BASE			(-60000)

#define HI6220_TEMP_RESET			(100000)

#define HI6220_TEMP_STEP			(785)

#define HI6220_TEMP_LAG				(3500)



#define HI3660_TEMP_BASE		(-63780)

#define HI3660_TEMP_STEP		(205)

#define HI3660_TEMP_LAG			(4000)



#define HI6220_DEFAULT_SENSOR		2

#define HI3660_DEFAULT_SENSOR		1

#define TEMP0_LAG			(0x0)

#define TEMP0_TH			(0x4)

#define TEMP0_RST_TH			(0x8)

#define TEMP0_CFG			(0xC)

#define TEMP0_CFG_SS_MSK		(0xF000)

#define TEMP0_CFG_HDAK_MSK		(0x30)

#define TEMP0_EN			(0x10)

#define TEMP0_INT_EN			(0x14)

#define TEMP0_INT_CLR			(0x18)

#define TEMP0_RST_MSK			(0x1C)

#define TEMP0_VALUE			(0x28)



#define HISI_TEMP_BASE			(-60000)

#define HISI_TEMP_RESET			(100000)

#define HISI_TEMP_STEP			(784)

#define HISI_TEMP_LAG			(3500)



#define HISI_MAX_SENSORS		4

#define HISI_DEFAULT_SENSOR		2



struct hisi_thermal_sensor {

	struct hisi_thermal_data *thermal;

	struct thermal_zone_device *tzd;



	long sensor_temp;

	uint32_t id;

	uint32_t thres_temp;

};



struct hisi_thermal_data {

	int (*get_temp)(struct hisi_thermal_data *data);

	int (*enable_sensor)(struct hisi_thermal_data *data);

	int (*disable_sensor)(struct hisi_thermal_data *data);

	int (*irq_handler)(struct hisi_thermal_data *data);

	struct mutex thermal_lock;    /* protects register data */

	struct platform_device *pdev;

	struct clk *clk;

	struct hisi_thermal_sensor sensor;

	void __iomem *regs;

	struct hisi_thermal_sensor sensors;

	int irq;

	void __iomem *regs;

};



/*

 * The temperature computation on the tsensor is as follow:

 *	Unit: millidegree Celsius

 *	Step: 200/255 (0.7843)

 *	Step: 255/200 (0.7843)

 *	Temperature base: -60°C

 *

 * The register is programmed in temperature steps, every step is 785

 * The register is programmed in temperature steps, every step is 784

 * millidegree and begins at -60 000 m°C

 *

 * The temperature from the steps:

 *

 *	Temp = TempBase + (steps x 785)

 *	Temp = TempBase + (steps x 784)

 *

 * and the steps from the temperature:

 *

 *	steps = (Temp - TempBase) / 785

 *	steps = (Temp - TempBase) / 784

 *

 */

static inline int hi6220_thermal_step_to_temp(int step)

static inline int hisi_thermal_step_to_temp(int step)

{

	return HI6220_TEMP_BASE + (step * HI6220_TEMP_STEP);

	return HISI_TEMP_BASE + (step * HISI_TEMP_STEP);

}



static inline int hi6220_thermal_temp_to_step(int temp)

static inline long hisi_thermal_temp_to_step(long temp)

{

	return DIV_ROUND_UP(temp - HI6220_TEMP_BASE, HI6220_TEMP_STEP);

	return (temp - HISI_TEMP_BASE) / HISI_TEMP_STEP;

}



/*

 * for Hi3660,

 *	Step: 189/922 (0.205)

 *	Temperature base: -63.780°C

 *

 * The register is programmed in temperature steps, every step is 205

 * millidegree and begins at -63 780 m°C

 */

static inline int hi3660_thermal_step_to_temp(int step)

static inline long hisi_thermal_round_temp(int temp)

{

	return HI3660_TEMP_BASE + step * HI3660_TEMP_STEP;

}



static inline int hi3660_thermal_temp_to_step(int temp)

{

	return DIV_ROUND_UP(temp - HI3660_TEMP_BASE, HI3660_TEMP_STEP);

	return hisi_thermal_step_to_temp(

		hisi_thermal_temp_to_step(temp));

}



/*
@@ -146,92 +122,51 @@ static inline int hi3660_thermal_temp_to_step(int temp) 
 *

 * [0:4] : lag register

 *

 * The temperature is coded in steps, cf. HI6220_TEMP_STEP.

 * The temperature is coded in steps, cf. HISI_TEMP_STEP.

 *

 * Min : 0x00 :  0.0 °C

 * Max : 0x1F : 24.3 °C

 *

 * The 'value' parameter is in milliCelsius.

 */

static inline void hi6220_thermal_set_lag(void __iomem *addr, int value)

static inline void hisi_thermal_set_lag(void __iomem *addr, int value)

{

	writel(DIV_ROUND_UP(value, HI6220_TEMP_STEP) & 0x1F,

			addr + HI6220_TEMP0_LAG);

	writel((value / HISI_TEMP_STEP) & 0x1F, addr + TEMP0_LAG);

}



static inline void hi6220_thermal_alarm_clear(void __iomem *addr, int value)

static inline void hisi_thermal_alarm_clear(void __iomem *addr, int value)

{

	writel(value, addr + HI6220_TEMP0_INT_CLR);

	writel(value, addr + TEMP0_INT_CLR);

}



static inline void hi6220_thermal_alarm_enable(void __iomem *addr, int value)

static inline void hisi_thermal_alarm_enable(void __iomem *addr, int value)

{

	writel(value, addr + HI6220_TEMP0_INT_EN);

	writel(value, addr + TEMP0_INT_EN);

}



static inline void hi6220_thermal_alarm_set(void __iomem *addr, int temp)

static inline void hisi_thermal_alarm_set(void __iomem *addr, int temp)

{

	writel(hi6220_thermal_temp_to_step(temp) | 0x0FFFFFF00,

	       addr + HI6220_TEMP0_TH);

	writel(hisi_thermal_temp_to_step(temp) | 0x0FFFFFF00, addr + TEMP0_TH);

}



static inline void hi6220_thermal_reset_set(void __iomem *addr, int temp)

static inline void hisi_thermal_reset_set(void __iomem *addr, int temp)

{

	writel(hi6220_thermal_temp_to_step(temp), addr + HI6220_TEMP0_RST_TH);

	writel(hisi_thermal_temp_to_step(temp), addr + TEMP0_RST_TH);

}



static inline void hi6220_thermal_reset_enable(void __iomem *addr, int value)

static inline void hisi_thermal_reset_enable(void __iomem *addr, int value)

{

	writel(value, addr + HI6220_TEMP0_RST_MSK);

	writel(value, addr + TEMP0_RST_MSK);

}



static inline void hi6220_thermal_enable(void __iomem *addr, int value)

static inline void hisi_thermal_enable(void __iomem *addr, int value)

{

	writel(value, addr + HI6220_TEMP0_EN);

	writel(value, addr + TEMP0_EN);

}



static inline int hi6220_thermal_get_temperature(void __iomem *addr)

static inline int hisi_thermal_get_temperature(void __iomem *addr)

{

	return hi6220_thermal_step_to_temp(readl(addr + HI6220_TEMP0_VALUE));

}



/*

 * [0:6] lag register

 *

 * The temperature is coded in steps, cf. HI3660_TEMP_STEP.

 *

 * Min : 0x00 :  0.0 °C

 * Max : 0x7F : 26.0 °C

 *

 */

static inline void hi3660_thermal_set_lag(void __iomem *addr,

					  int id, int value)

{

	writel(DIV_ROUND_UP(value, HI3660_TEMP_STEP) & 0x7F,

			addr + HI3660_LAG(id));

}



static inline void hi3660_thermal_alarm_clear(void __iomem *addr,

					      int id, int value)

{

	writel(value, addr + HI3660_INT_CLR(id));

}



static inline void hi3660_thermal_alarm_enable(void __iomem *addr,

					       int id, int value)

{

	writel(value, addr + HI3660_INT_EN(id));

}



static inline void hi3660_thermal_alarm_set(void __iomem *addr,

					    int id, int value)

{

	writel(value, addr + HI3660_TH(id));

}



static inline int hi3660_thermal_get_temperature(void __iomem *addr, int id)

{

	return hi3660_thermal_step_to_temp(readl(addr + HI3660_TEMP(id)));

	return hisi_thermal_step_to_temp(readl(addr + TEMP0_VALUE));

}



/*
@@ -244,10 +179,10 @@ static inline int hi3660_thermal_get_temperature(void __iomem *addr, int id) 
 * 0x2: remote sensor 2 (ACPU cluster 0)

 * 0x3: remote sensor 3 (G3D)

 */

static inline void hi6220_thermal_sensor_select(void __iomem *addr, int sensor)

static inline void hisi_thermal_sensor_select(void __iomem *addr, int sensor)

{

	writel((readl(addr + HI6220_TEMP0_CFG) & ~HI6220_TEMP0_CFG_SS_MSK) |

	       (sensor << 12), addr + HI6220_TEMP0_CFG);

	writel((readl(addr + TEMP0_CFG) & ~TEMP0_CFG_SS_MSK) |

	       (sensor << 12), addr + TEMP0_CFG);

}



/*
@@ -260,182 +195,30 @@ static inline void hi6220_thermal_sensor_select(void __iomem *addr, int sensor) 
 * 0x2 :  49.152 ms

 * 0x3 : 393.216 ms

 */

static inline void hi6220_thermal_hdak_set(void __iomem *addr, int value)

{

	writel((readl(addr + HI6220_TEMP0_CFG) & ~HI6220_TEMP0_CFG_HDAK_MSK) |

	       (value << 4), addr + HI6220_TEMP0_CFG);

}



static int hi6220_thermal_irq_handler(struct hisi_thermal_data *data)

{

	hi6220_thermal_alarm_clear(data->regs, 1);

	return 0;

}



static int hi3660_thermal_irq_handler(struct hisi_thermal_data *data)

{

	hi3660_thermal_alarm_clear(data->regs, data->sensor.id, 1);

	return 0;

}



static int hi6220_thermal_get_temp(struct hisi_thermal_data *data)

static inline void hisi_thermal_hdak_set(void __iomem *addr, int value)

{

	return hi6220_thermal_get_temperature(data->regs);

	writel((readl(addr + TEMP0_CFG) & ~TEMP0_CFG_HDAK_MSK) |

	       (value << 4), addr + TEMP0_CFG);

}



static int hi3660_thermal_get_temp(struct hisi_thermal_data *data)

static void hisi_thermal_disable_sensor(struct hisi_thermal_data *data)

{

	return hi3660_thermal_get_temperature(data->regs, data->sensor.id);

}

	mutex_lock(&data->thermal_lock);



static int hi6220_thermal_disable_sensor(struct hisi_thermal_data *data)

{

	/* disable sensor module */

	hi6220_thermal_enable(data->regs, 0);

	hi6220_thermal_alarm_enable(data->regs, 0);

	hi6220_thermal_reset_enable(data->regs, 0);



	clk_disable_unprepare(data->clk);



	return 0;

}



static int hi3660_thermal_disable_sensor(struct hisi_thermal_data *data)

{

	/* disable sensor module */

	hi3660_thermal_alarm_enable(data->regs, data->sensor.id, 0);

	return 0;

}



static int hi6220_thermal_enable_sensor(struct hisi_thermal_data *data)

{

	struct hisi_thermal_sensor *sensor = &data->sensor;

	int ret;



	/* enable clock for tsensor */

	ret = clk_prepare_enable(data->clk);

	if (ret)

		return ret;



	/* disable module firstly */

	hi6220_thermal_reset_enable(data->regs, 0);

	hi6220_thermal_enable(data->regs, 0);



	/* select sensor id */

	hi6220_thermal_sensor_select(data->regs, sensor->id);



	/* setting the hdak time */

	hi6220_thermal_hdak_set(data->regs, 0);



	/* setting lag value between current temp and the threshold */

	hi6220_thermal_set_lag(data->regs, HI6220_TEMP_LAG);



	/* enable for interrupt */

	hi6220_thermal_alarm_set(data->regs, sensor->thres_temp);



	hi6220_thermal_reset_set(data->regs, HI6220_TEMP_RESET);



	/* enable module */

	hi6220_thermal_reset_enable(data->regs, 1);

	hi6220_thermal_enable(data->regs, 1);



	hi6220_thermal_alarm_clear(data->regs, 0);

	hi6220_thermal_alarm_enable(data->regs, 1);



	return 0;

}



static int hi3660_thermal_enable_sensor(struct hisi_thermal_data *data)

{

	unsigned int value;

	struct hisi_thermal_sensor *sensor = &data->sensor;



	/* disable interrupt */

	hi3660_thermal_alarm_enable(data->regs, sensor->id, 0);



	/* setting lag value between current temp and the threshold */

	hi3660_thermal_set_lag(data->regs, sensor->id, HI3660_TEMP_LAG);



	/* set interrupt threshold */

	value = hi3660_thermal_temp_to_step(sensor->thres_temp);

	hi3660_thermal_alarm_set(data->regs, sensor->id, value);



	/* enable interrupt */

	hi3660_thermal_alarm_clear(data->regs, sensor->id, 1);

	hi3660_thermal_alarm_enable(data->regs, sensor->id, 1);



	return 0;

}



static int hi6220_thermal_probe(struct hisi_thermal_data *data)

{

	struct platform_device *pdev = data->pdev;

	struct device *dev = &pdev->dev;

	struct resource *res;

	int ret;



	data->get_temp = hi6220_thermal_get_temp;

	data->enable_sensor = hi6220_thermal_enable_sensor;

	data->disable_sensor = hi6220_thermal_disable_sensor;

	data->irq_handler = hi6220_thermal_irq_handler;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	data->regs = devm_ioremap_resource(dev, res);

	if (IS_ERR(data->regs)) {

		dev_err(dev, "failed to get io address\n");

		return PTR_ERR(data->regs);

	}



	data->clk = devm_clk_get(dev, "thermal_clk");

	if (IS_ERR(data->clk)) {

		ret = PTR_ERR(data->clk);

		if (ret != -EPROBE_DEFER)

			dev_err(dev, "failed to get thermal clk: %d\n", ret);

		return ret;

	}



	data->irq = platform_get_irq(pdev, 0);

	if (data->irq < 0)

		return data->irq;



	data->sensor.id = HI6220_DEFAULT_SENSOR;



	return 0;

}



static int hi3660_thermal_probe(struct hisi_thermal_data *data)

{

	struct platform_device *pdev = data->pdev;

	struct device *dev = &pdev->dev;

	struct resource *res;



	data->get_temp = hi3660_thermal_get_temp;

	data->enable_sensor = hi3660_thermal_enable_sensor;

	data->disable_sensor = hi3660_thermal_disable_sensor;

	data->irq_handler = hi3660_thermal_irq_handler;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	data->regs = devm_ioremap_resource(dev, res);

	if (IS_ERR(data->regs)) {

		dev_err(dev, "failed to get io address\n");

		return PTR_ERR(data->regs);

	}



	data->irq = platform_get_irq(pdev, 0);

	if (data->irq < 0)

		return data->irq;



	data->sensor.id = HI3660_DEFAULT_SENSOR;

	hisi_thermal_enable(data->regs, 0);

	hisi_thermal_alarm_enable(data->regs, 0);

	hisi_thermal_reset_enable(data->regs, 0);



	return 0;

	mutex_unlock(&data->thermal_lock);

}



static int hisi_thermal_get_temp(void *__data, int *temp)

static int hisi_thermal_get_temp(void *_sensor, int *temp)

{

	struct hisi_thermal_data *data = __data;

	struct hisi_thermal_sensor *sensor = &data->sensor;

	struct hisi_thermal_sensor *sensor = _sensor;

	struct hisi_thermal_data *data = sensor->thermal;



	*temp = data->get_temp(data);

	*temp = hisi_thermal_get_temperature(data->regs);



	dev_dbg(&data->pdev->dev, "id=%d, temp=%d, thres=%d\n",

		sensor->id, *temp, sensor->thres_temp);
@@ -450,21 +233,21 @@ static const struct thermal_zone_of_device_ops hisi_of_thermal_ops = { 
static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev)

{

	struct hisi_thermal_data *data = dev;

	struct hisi_thermal_sensor *sensor = &data->sensor;

	int temp = 0;

	struct hisi_thermal_sensor *sensor = &data->sensors;

	int temp;



	data->irq_handler(data);

	hisi_thermal_alarm_clear(data->regs, 1);



	hisi_thermal_get_temp(data, &temp);

	temp = hisi_thermal_get_temperature(data->regs);



	if (temp >= sensor->thres_temp) {

		dev_crit(&data->pdev->dev, "THERMAL ALARM: %d > %d\n",

			 temp, sensor->thres_temp);



		thermal_zone_device_update(data->sensor.tzd,

		thermal_zone_device_update(data->sensors.tzd,

					   THERMAL_EVENT_UNSPECIFIED);



	} else {

	} else if (temp < sensor->thres_temp) {

		dev_crit(&data->pdev->dev, "THERMAL ALARM stopped: %d < %d\n",

			 temp, sensor->thres_temp);

	}
@@ -474,14 +257,17 @@ static irqreturn_t hisi_thermal_alarm_irq_thread(int irq, void *dev) 


static int hisi_thermal_register_sensor(struct platform_device *pdev,

					struct hisi_thermal_data *data,

					struct hisi_thermal_sensor *sensor)

					struct hisi_thermal_sensor *sensor,

					int index)

{

	int ret, i;

	const struct thermal_trip *trip;



	sensor->id = index;

	sensor->thermal = data;



	sensor->tzd = devm_thermal_zone_of_sensor_register(&pdev->dev,

							   sensor->id, data,

							   &hisi_of_thermal_ops);

				sensor->id, sensor, &hisi_of_thermal_ops);

	if (IS_ERR(sensor->tzd)) {

		ret = PTR_ERR(sensor->tzd);

		sensor->tzd = NULL;
@@ -494,7 +280,7 @@ static int hisi_thermal_register_sensor(struct platform_device *pdev, 


	for (i = 0; i < of_thermal_get_ntrips(sensor->tzd); i++) {

		if (trip[i].type == THERMAL_TRIP_PASSIVE) {

			sensor->thres_temp = trip[i].temperature;

			sensor->thres_temp = hisi_thermal_round_temp(trip[i].temperature);

			break;

		}

	}
@@ -503,14 +289,7 @@ static int hisi_thermal_register_sensor(struct platform_device *pdev, 
}



static const struct of_device_id of_hisi_thermal_match[] = {

	{

		.compatible = "hisilicon,tsensor",

		.data = hi6220_thermal_probe

	},

	{

		.compatible = "hisilicon,hi3660-tsensor",

		.data = hi3660_thermal_probe

	},

	{ .compatible = "hisilicon,tsensor" },

	{ /* end */ }

};

MODULE_DEVICE_TABLE(of, of_hisi_thermal_match);
@@ -561,51 +340,69 @@ static int hisi_thermal_setup(struct hisi_thermal_data *data) 
static int hisi_thermal_probe(struct platform_device *pdev)

{

	struct hisi_thermal_data *data;

	int const (*platform_probe)(struct hisi_thermal_data *);

	struct device *dev = &pdev->dev;

	struct resource *res;

	int ret;



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

	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	mutex_init(&data->thermal_lock);

	data->pdev = pdev;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	data->regs = devm_ioremap_resource(&pdev->dev, res);

	if (IS_ERR(data->regs)) {

		dev_err(&pdev->dev, "failed to get io address\n");

		return PTR_ERR(data->regs);

	}



	data->irq = platform_get_irq(pdev, 0);

	if (data->irq < 0)

		return data->irq;



	platform_set_drvdata(pdev, data);



	platform_probe = of_device_get_match_data(dev);

	if (!platform_probe) {

		dev_err(dev, "failed to get probe func\n");

		return -EINVAL;

	data->clk = devm_clk_get(&pdev->dev, "thermal_clk");

	if (IS_ERR(data->clk)) {

		ret = PTR_ERR(data->clk);

		if (ret != -EPROBE_DEFER)

			dev_err(&pdev->dev,

				"failed to get thermal clk: %d\n", ret);

		return ret;

	}



	ret = platform_probe(data);

	if (ret)

	/* enable clock for thermal */

	ret = clk_prepare_enable(data->clk);

	if (ret) {

		dev_err(&pdev->dev, "failed to enable thermal clk: %d\n", ret);

		return ret;

	}



	ret = hisi_thermal_register_sensor(pdev, data,

					   &data->sensor);

					   &data->sensors,

					   HISI_DEFAULT_SENSOR);

	if (ret) {

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

		dev_err(&pdev->dev, "failed to register thermal sensor: %d\n",

			ret);

		return ret;

	}



	ret = data->enable_sensor(data);

	ret = hisi_thermal_setup(data);

	if (ret) {

		dev_err(dev, "Failed to setup the sensor: %d\n", ret);

		dev_err(&pdev->dev, "Failed to setup the sensor: %d\n", ret);

		return ret;

	}



	if (data->irq) {

		ret = devm_request_threaded_irq(dev, data->irq, NULL,

	ret = devm_request_threaded_irq(&pdev->dev, data->irq, NULL,

					hisi_thermal_alarm_irq_thread,

					IRQF_ONESHOT, "hisi_thermal", data);

	if (ret < 0) {

			dev_err(dev, "failed to request alarm irq: %d\n", ret);

		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);

		return ret;

	}

	}



	hisi_thermal_toggle_sensor(&data->sensor, true);

	hisi_thermal_toggle_sensor(&data->sensors, true);



	return 0;

}
@@ -613,11 +410,11 @@ static int hisi_thermal_probe(struct platform_device *pdev) 
static int hisi_thermal_remove(struct platform_device *pdev)

{

	struct hisi_thermal_data *data = platform_get_drvdata(pdev);

	struct hisi_thermal_sensor *sensor = &data->sensor;

	struct hisi_thermal_sensor *sensor = &data->sensors;



	hisi_thermal_toggle_sensor(sensor, false);



	data->disable_sensor(data);

	hisi_thermal_disable_sensor(data);

	clk_disable_unprepare(data->clk);



	return 0;

}
@@ -627,7 +424,9 @@ static int hisi_thermal_suspend(struct device *dev) 
{

	struct hisi_thermal_data *data = dev_get_drvdata(dev);



	data->disable_sensor(data);

	hisi_thermal_disable_sensor(data);



	clk_disable_unprepare(data->clk);



	return 0;

}
@@ -635,8 +434,15 @@ static int hisi_thermal_suspend(struct device *dev) 
static int hisi_thermal_resume(struct device *dev)

{

	struct hisi_thermal_data *data = dev_get_drvdata(dev);

	int ret;



	ret = clk_prepare_enable(data->clk);

	if (ret)

		return ret;



	return data->enable_sensor(data);

	hisi_thermal_setup(data);



	return 0;

}

#endif