[mirror_ubuntu-bionic-kernel.git] / drivers / thermal / imx_thermal.c

/*
 * Copyright 2013 Freescale Semiconductor, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/clk.h>
#include <linux/cpu_cooling.h>
#include <linux/cpufreq.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/thermal.h>
#include <linux/types.h>

#define REG_SET		0x4
#define REG_CLR		0x8
#define REG_TOG		0xc

#define MISC0				0x0150
#define MISC0_REFTOP_SELBIASOFF		(1 << 3)

#define TEMPSENSE0			0x0180
#define TEMPSENSE0_ALARM_VALUE_SHIFT	20
#define TEMPSENSE0_ALARM_VALUE_MASK	(0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT)
#define TEMPSENSE0_TEMP_CNT_SHIFT	8
#define TEMPSENSE0_TEMP_CNT_MASK	(0xfff << TEMPSENSE0_TEMP_CNT_SHIFT)
#define TEMPSENSE0_FINISHED		(1 << 2)
#define TEMPSENSE0_MEASURE_TEMP		(1 << 1)
#define TEMPSENSE0_POWER_DOWN		(1 << 0)

#define TEMPSENSE1			0x0190
#define TEMPSENSE1_MEASURE_FREQ		0xffff

#define OCOTP_ANA1			0x04e0

/* The driver supports 1 passive trip point and 1 critical trip point */
enum imx_thermal_trip {
	IMX_TRIP_PASSIVE,
	IMX_TRIP_CRITICAL,
	IMX_TRIP_NUM,
};

/*
 * It defines the temperature in millicelsius for passive trip point
 * that will trigger cooling action when crossed.
 */
#define IMX_TEMP_PASSIVE		85000

#define IMX_POLLING_DELAY		2000 /* millisecond */
#define IMX_PASSIVE_DELAY		1000

struct imx_thermal_data {
	struct thermal_zone_device *tz;
	struct thermal_cooling_device *cdev;
	enum thermal_device_mode mode;
	struct regmap *tempmon;
	int c1, c2; /* See formula in imx_get_sensor_data() */
	unsigned long temp_passive;
	unsigned long temp_critical;
	unsigned long alarm_temp;
	unsigned long last_temp;
	bool irq_enabled;
	int irq;
	struct clk *thermal_clk;
};

static void imx_set_alarm_temp(struct imx_thermal_data *data,
			       signed long alarm_temp)
{
	struct regmap *map = data->tempmon;
	int alarm_value;

	data->alarm_temp = alarm_temp;
	alarm_value = (alarm_temp - data->c2) / data->c1;
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK);
	regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value <<
			TEMPSENSE0_ALARM_VALUE_SHIFT);
}

static int imx_get_temp(struct thermal_zone_device *tz, unsigned long *temp)
{
	struct imx_thermal_data *data = tz->devdata;
	struct regmap *map = data->tempmon;
	unsigned int n_meas;
	bool wait;
	u32 val;

	if (data->mode == THERMAL_DEVICE_ENABLED) {
		/* Check if a measurement is currently in progress */
		regmap_read(map, TEMPSENSE0, &val);
		wait = !(val & TEMPSENSE0_FINISHED);
	} else {
		/*
		 * Every time we measure the temperature, we will power on the
		 * temperature sensor, enable measurements, take a reading,
		 * disable measurements, power off the temperature sensor.
		 */
		regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
		regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);

		wait = true;
	}

	/*
	 * According to the temp sensor designers, it may require up to ~17us
	 * to complete a measurement.
	 */
	if (wait)
		usleep_range(20, 50);

	regmap_read(map, TEMPSENSE0, &val);

	if (data->mode != THERMAL_DEVICE_ENABLED) {
		regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
		regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	}

	if ((val & TEMPSENSE0_FINISHED) == 0) {
		dev_dbg(&tz->device, "temp measurement never finished\n");
		return -EAGAIN;
	}

	n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT;

	/* See imx_get_sensor_data() for formula derivation */
	*temp = data->c2 + data->c1 * n_meas;

	/* Update alarm value to next higher trip point */
	if (data->alarm_temp == data->temp_passive && *temp >= data->temp_passive)
		imx_set_alarm_temp(data, data->temp_critical);
	if (data->alarm_temp == data->temp_critical && *temp < data->temp_passive) {
		imx_set_alarm_temp(data, data->temp_passive);
		dev_dbg(&tz->device, "thermal alarm off: T < %lu\n",
			data->alarm_temp / 1000);
	}

	if (*temp != data->last_temp) {
		dev_dbg(&tz->device, "millicelsius: %ld\n", *temp);
		data->last_temp = *temp;
	}

	/* Reenable alarm IRQ if temperature below alarm temperature */
	if (!data->irq_enabled && *temp < data->alarm_temp) {
		data->irq_enabled = true;
		enable_irq(data->irq);
	}

	return 0;
}

static int imx_get_mode(struct thermal_zone_device *tz,
			enum thermal_device_mode *mode)
{
	struct imx_thermal_data *data = tz->devdata;

	*mode = data->mode;

	return 0;
}

static int imx_set_mode(struct thermal_zone_device *tz,
			enum thermal_device_mode mode)
{
	struct imx_thermal_data *data = tz->devdata;
	struct regmap *map = data->tempmon;

	if (mode == THERMAL_DEVICE_ENABLED) {
		tz->polling_delay = IMX_POLLING_DELAY;
		tz->passive_delay = IMX_PASSIVE_DELAY;

		regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
		regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);

		if (!data->irq_enabled) {
			data->irq_enabled = true;
			enable_irq(data->irq);
		}
	} else {
		regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
		regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);

		tz->polling_delay = 0;
		tz->passive_delay = 0;

		if (data->irq_enabled) {
			disable_irq(data->irq);
			data->irq_enabled = false;
		}
	}

	data->mode = mode;
	thermal_zone_device_update(tz);

	return 0;
}

static int imx_get_trip_type(struct thermal_zone_device *tz, int trip,
			     enum thermal_trip_type *type)
{
	*type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE :
					     THERMAL_TRIP_CRITICAL;
	return 0;
}

static int imx_get_crit_temp(struct thermal_zone_device *tz,
			     unsigned long *temp)
{
	struct imx_thermal_data *data = tz->devdata;

	*temp = data->temp_critical;
	return 0;
}

static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip,
			     unsigned long *temp)
{
	struct imx_thermal_data *data = tz->devdata;

	*temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive :
					     data->temp_critical;
	return 0;
}

static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip,
			     unsigned long temp)
{
	struct imx_thermal_data *data = tz->devdata;

	if (trip == IMX_TRIP_CRITICAL)
		return -EPERM;

	if (temp > IMX_TEMP_PASSIVE)
		return -EINVAL;

	data->temp_passive = temp;

	imx_set_alarm_temp(data, temp);

	return 0;
}

static int imx_bind(struct thermal_zone_device *tz,
		    struct thermal_cooling_device *cdev)
{
	int ret;

	ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev,
					       THERMAL_NO_LIMIT,
					       THERMAL_NO_LIMIT);
	if (ret) {
		dev_err(&tz->device,
			"binding zone %s with cdev %s failed:%d\n",
			tz->type, cdev->type, ret);
		return ret;
	}

	return 0;
}

static int imx_unbind(struct thermal_zone_device *tz,
		      struct thermal_cooling_device *cdev)
{
	int ret;

	ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev);
	if (ret) {
		dev_err(&tz->device,
			"unbinding zone %s with cdev %s failed:%d\n",
			tz->type, cdev->type, ret);
		return ret;
	}

	return 0;
}

static struct thermal_zone_device_ops imx_tz_ops = {
	.bind = imx_bind,
	.unbind = imx_unbind,
	.get_temp = imx_get_temp,
	.get_mode = imx_get_mode,
	.set_mode = imx_set_mode,
	.get_trip_type = imx_get_trip_type,
	.get_trip_temp = imx_get_trip_temp,
	.get_crit_temp = imx_get_crit_temp,
	.set_trip_temp = imx_set_trip_temp,
};

static int imx_get_sensor_data(struct platform_device *pdev)
{
	struct imx_thermal_data *data = platform_get_drvdata(pdev);
	struct regmap *map;
	int t1, t2, n1, n2;
	int ret;
	u32 val;

	map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
					      "fsl,tempmon-data");
	if (IS_ERR(map)) {
		ret = PTR_ERR(map);
		dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret);
		return ret;
	}

	ret = regmap_read(map, OCOTP_ANA1, &val);
	if (ret) {
		dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret);
		return ret;
	}

	if (val == 0 || val == ~0) {
		dev_err(&pdev->dev, "invalid sensor calibration data\n");
		return -EINVAL;
	}

	/*
	 * Sensor data layout:
	 *   [31:20] - sensor value @ 25C
	 *    [19:8] - sensor value of hot
	 *     [7:0] - hot temperature value
	 */
	n1 = val >> 20;
	n2 = (val & 0xfff00) >> 8;
	t2 = val & 0xff;
	t1 = 25; /* t1 always 25C */

	/*
	 * Derived from linear interpolation,
	 * Tmeas = T2 + (Nmeas - N2) * (T1 - T2) / (N1 - N2)
	 * We want to reduce this down to the minimum computation necessary
	 * for each temperature read.  Also, we want Tmeas in millicelsius
	 * and we don't want to lose precision from integer division. So...
	 * milli_Tmeas = 1000 * T2 + 1000 * (Nmeas - N2) * (T1 - T2) / (N1 - N2)
	 * Let constant c1 = 1000 * (T1 - T2) / (N1 - N2)
	 * milli_Tmeas = (1000 * T2) + c1 * (Nmeas - N2)
	 * milli_Tmeas = (1000 * T2) + (c1 * Nmeas) - (c1 * N2)
	 * Let constant c2 = (1000 * T2) - (c1 * N2)
	 * milli_Tmeas = c2 + (c1 * Nmeas)
	 */
	data->c1 = 1000 * (t1 - t2) / (n1 - n2);
	data->c2 = 1000 * t2 - data->c1 * n2;

	/*
	 * Set the default passive cooling trip point to 20 °C below the
	 * maximum die temperature. Can be changed from userspace.
	 */
	data->temp_passive = 1000 * (t2 - 20);

	/*
	 * The maximum die temperature is t2, let's give 5 °C cushion
	 * for noise and possible temperature rise between measurements.
	 */
	data->temp_critical = 1000 * (t2 - 5);

	return 0;
}

static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev)
{
	struct imx_thermal_data *data = dev;

	disable_irq_nosync(irq);
	data->irq_enabled = false;

	return IRQ_WAKE_THREAD;
}

static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev)
{
	struct imx_thermal_data *data = dev;

	dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n",
		data->alarm_temp / 1000);

	thermal_zone_device_update(data->tz);

	return IRQ_HANDLED;
}

static int imx_thermal_probe(struct platform_device *pdev)
{
	struct imx_thermal_data *data;
	struct cpumask clip_cpus;
	struct regmap *map;
	int measure_freq;
	int ret;

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

	map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon");
	if (IS_ERR(map)) {
		ret = PTR_ERR(map);
		dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret);
		return ret;
	}
	data->tempmon = map;

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

	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
			imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread,
			0, "imx_thermal", data);
	if (ret < 0) {
		dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
		return ret;
	}

	platform_set_drvdata(pdev, data);

	ret = imx_get_sensor_data(pdev);
	if (ret) {
		dev_err(&pdev->dev, "failed to get sensor data\n");
		return ret;
	}

	/* Make sure sensor is in known good state for measurements */
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
	regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF);
	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);

	cpumask_set_cpu(0, &clip_cpus);
	data->cdev = cpufreq_cooling_register(&clip_cpus);
	if (IS_ERR(data->cdev)) {
		ret = PTR_ERR(data->cdev);
		dev_err(&pdev->dev,
			"failed to register cpufreq cooling device: %d\n", ret);
		return ret;
	}

	data->tz = thermal_zone_device_register("imx_thermal_zone",
						IMX_TRIP_NUM,
						BIT(IMX_TRIP_PASSIVE), data,
						&imx_tz_ops, NULL,
						IMX_PASSIVE_DELAY,
						IMX_POLLING_DELAY);
	if (IS_ERR(data->tz)) {
		ret = PTR_ERR(data->tz);
		dev_err(&pdev->dev,
			"failed to register thermal zone device %d\n", ret);
		cpufreq_cooling_unregister(data->cdev);
		return ret;
	}

	data->thermal_clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(data->thermal_clk)) {
		dev_warn(&pdev->dev, "failed to get thermal clk!\n");
	} else {
		/*
		 * Thermal sensor needs clk on to get correct value, normally
		 * we should enable its clk before taking measurement and disable
		 * clk after measurement is done, but if alarm function is enabled,
		 * hardware will auto measure the temperature periodically, so we
		 * need to keep the clk always on for alarm function.
		 */
		ret = clk_prepare_enable(data->thermal_clk);
		if (ret)
			dev_warn(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
	}

	/* Enable measurements at ~ 10 Hz */
	regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
	measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */
	regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq);
	imx_set_alarm_temp(data, data->temp_passive);
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);

	data->irq_enabled = true;
	data->mode = THERMAL_DEVICE_ENABLED;

	return 0;
}

static int imx_thermal_remove(struct platform_device *pdev)
{
	struct imx_thermal_data *data = platform_get_drvdata(pdev);
	struct regmap *map = data->tempmon;

	/* Disable measurements */
	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	if (!IS_ERR(data->thermal_clk))
		clk_disable_unprepare(data->thermal_clk);

	thermal_zone_device_unregister(data->tz);
	cpufreq_cooling_unregister(data->cdev);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int imx_thermal_suspend(struct device *dev)
{
	struct imx_thermal_data *data = dev_get_drvdata(dev);
	struct regmap *map = data->tempmon;

	/*
	 * Need to disable thermal sensor, otherwise, when thermal core
	 * try to get temperature before thermal sensor resume, a wrong
	 * temperature will be read as the thermal sensor is powered
	 * down.
	 */
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	data->mode = THERMAL_DEVICE_DISABLED;

	return 0;
}

static int imx_thermal_resume(struct device *dev)
{
	struct imx_thermal_data *data = dev_get_drvdata(dev);
	struct regmap *map = data->tempmon;

	/* Enabled thermal sensor after resume */
	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
	data->mode = THERMAL_DEVICE_ENABLED;

	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops,
			 imx_thermal_suspend, imx_thermal_resume);

static const struct of_device_id of_imx_thermal_match[] = {
	{ .compatible = "fsl,imx6q-tempmon", },
	{ /* end */ }
};
MODULE_DEVICE_TABLE(of, of_imx_thermal_match);

static struct platform_driver imx_thermal = {
	.driver = {
		.name	= "imx_thermal",
		.owner  = THIS_MODULE,
		.pm	= &imx_thermal_pm_ops,
		.of_match_table = of_imx_thermal_match,
	},
	.probe		= imx_thermal_probe,
	.remove		= imx_thermal_remove,
};
module_platform_driver(imx_thermal);

MODULE_AUTHOR("Freescale Semiconductor, Inc.");
MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:imx-thermal");
Commit	Line	Data
ca3de46b SG	1	/*
	2	* Copyright 2013 Freescale Semiconductor, Inc.
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	*/
	9
329fe7b1	10	#include <linux/clk.h>
ca3de46b SG	11	#include <linux/cpu_cooling.h>
	12	#include <linux/cpufreq.h>
	13	#include <linux/delay.h>
	14	#include <linux/device.h>
	15	#include <linux/init.h>
37713a1e	16	#include <linux/interrupt.h>
ca3de46b SG	17	#include <linux/io.h>
	18	#include <linux/kernel.h>
	19	#include <linux/mfd/syscon.h>
	20	#include <linux/module.h>
	21	#include <linux/of.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/regmap.h>
	24	#include <linux/slab.h>
	25	#include <linux/thermal.h>
	26	#include <linux/types.h>
	27
	28	#define REG_SET 0x4
	29	#define REG_CLR 0x8
	30	#define REG_TOG 0xc
	31
	32	#define MISC0 0x0150
	33	#define MISC0_REFTOP_SELBIASOFF (1 << 3)
	34
	35	#define TEMPSENSE0 0x0180
37713a1e PZ	36	#define TEMPSENSE0_ALARM_VALUE_SHIFT 20
37713a1e PZ	37	#define TEMPSENSE0_ALARM_VALUE_MASK (0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT)
ca3de46b SG	38	#define TEMPSENSE0_TEMP_CNT_SHIFT 8
	39	#define TEMPSENSE0_TEMP_CNT_MASK (0xfff << TEMPSENSE0_TEMP_CNT_SHIFT)
	40	#define TEMPSENSE0_FINISHED (1 << 2)
	41	#define TEMPSENSE0_MEASURE_TEMP (1 << 1)
	42	#define TEMPSENSE0_POWER_DOWN (1 << 0)
	43
	44	#define TEMPSENSE1 0x0190
	45	#define TEMPSENSE1_MEASURE_FREQ 0xffff
	46
	47	#define OCOTP_ANA1 0x04e0
	48
	49	/* The driver supports 1 passive trip point and 1 critical trip point */
	50	enum imx_thermal_trip {
	51	IMX_TRIP_PASSIVE,
	52	IMX_TRIP_CRITICAL,
	53	IMX_TRIP_NUM,
	54	};
	55
	56	/*
	57	* It defines the temperature in millicelsius for passive trip point
	58	* that will trigger cooling action when crossed.
	59	*/
	60	#define IMX_TEMP_PASSIVE 85000
	61
ca3de46b SG	62	#define IMX_POLLING_DELAY 2000 /* millisecond */
	63	#define IMX_PASSIVE_DELAY 1000
	64
	65	struct imx_thermal_data {
	66	struct thermal_zone_device *tz;
	67	struct thermal_cooling_device *cdev;
	68	enum thermal_device_mode mode;
	69	struct regmap *tempmon;
	70	int c1, c2; /* See formula in imx_get_sensor_data() */
017e5142 PZ	71	unsigned long temp_passive;
017e5142 PZ	72	unsigned long temp_critical;
37713a1e PZ	73	unsigned long alarm_temp;
	74	unsigned long last_temp;
	75	bool irq_enabled;
	76	int irq;
329fe7b1	77	struct clk *thermal_clk;
ca3de46b SG	78	};
ca3de46b SG	79
37713a1e PZ	80	static void imx_set_alarm_temp(struct imx_thermal_data *data,
	81	signed long alarm_temp)
	82	{
	83	struct regmap *map = data->tempmon;
	84	int alarm_value;
	85
	86	data->alarm_temp = alarm_temp;
	87	alarm_value = (alarm_temp - data->c2) / data->c1;
	88	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK);
	89	regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value <<
	90	TEMPSENSE0_ALARM_VALUE_SHIFT);
	91	}
	92
ca3de46b SG	93	static int imx_get_temp(struct thermal_zone_device tz, unsigned long temp)
	94	{
	95	struct imx_thermal_data *data = tz->devdata;
	96	struct regmap *map = data->tempmon;
ca3de46b	97	unsigned int n_meas;
37713a1e	98	bool wait;
ca3de46b SG	99	u32 val;
ca3de46b SG	100
37713a1e PZ	101	if (data->mode == THERMAL_DEVICE_ENABLED) {
	102	/* Check if a measurement is currently in progress */
	103	regmap_read(map, TEMPSENSE0, &val);
	104	wait = !(val & TEMPSENSE0_FINISHED);
	105	} else {
	106	/*
	107	* Every time we measure the temperature, we will power on the
	108	* temperature sensor, enable measurements, take a reading,
	109	* disable measurements, power off the temperature sensor.
	110	*/
	111	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	112	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
	113
	114	wait = true;
	115	}
ca3de46b SG	116
	117	/*
	118	* According to the temp sensor designers, it may require up to ~17us
	119	* to complete a measurement.
	120	*/
37713a1e PZ	121	if (wait)
37713a1e PZ	122	usleep_range(20, 50);
ca3de46b SG	123
ca3de46b SG	124	regmap_read(map, TEMPSENSE0, &val);
37713a1e PZ	125
	126	if (data->mode != THERMAL_DEVICE_ENABLED) {
	127	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	128	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	129	}
ca3de46b SG	130
	131	if ((val & TEMPSENSE0_FINISHED) == 0) {
	132	dev_dbg(&tz->device, "temp measurement never finished\n");
	133	return -EAGAIN;
	134	}
	135
	136	n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT;
	137
	138	/* See imx_get_sensor_data() for formula derivation */
	139	temp = data->c2 + data->c1 n_meas;
	140
37713a1e PZ	141	/* Update alarm value to next higher trip point */
	142	if (data->alarm_temp == data->temp_passive && *temp >= data->temp_passive)
	143	imx_set_alarm_temp(data, data->temp_critical);
	144	if (data->alarm_temp == data->temp_critical && *temp < data->temp_passive) {
	145	imx_set_alarm_temp(data, data->temp_passive);
	146	dev_dbg(&tz->device, "thermal alarm off: T < %lu\n",
	147	data->alarm_temp / 1000);
	148	}
	149
	150	if (*temp != data->last_temp) {
ca3de46b	151	dev_dbg(&tz->device, "millicelsius: %ld\n", *temp);
37713a1e PZ	152	data->last_temp = *temp;
	153	}
	154
	155	/* Reenable alarm IRQ if temperature below alarm temperature */
	156	if (!data->irq_enabled && *temp < data->alarm_temp) {
	157	data->irq_enabled = true;
	158	enable_irq(data->irq);
ca3de46b SG	159	}
	160
	161	return 0;
	162	}
	163
	164	static int imx_get_mode(struct thermal_zone_device *tz,
	165	enum thermal_device_mode *mode)
	166	{
	167	struct imx_thermal_data *data = tz->devdata;
	168
	169	*mode = data->mode;
	170
	171	return 0;
	172	}
	173
	174	static int imx_set_mode(struct thermal_zone_device *tz,
	175	enum thermal_device_mode mode)
	176	{
	177	struct imx_thermal_data *data = tz->devdata;
37713a1e	178	struct regmap *map = data->tempmon;
ca3de46b SG	179
	180	if (mode == THERMAL_DEVICE_ENABLED) {
	181	tz->polling_delay = IMX_POLLING_DELAY;
	182	tz->passive_delay = IMX_PASSIVE_DELAY;
37713a1e PZ	183
	184	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	185	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
	186
	187	if (!data->irq_enabled) {
	188	data->irq_enabled = true;
	189	enable_irq(data->irq);
	190	}
ca3de46b	191	} else {
37713a1e PZ	192	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	193	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	194
ca3de46b SG	195	tz->polling_delay = 0;
ca3de46b SG	196	tz->passive_delay = 0;
37713a1e PZ	197
	198	if (data->irq_enabled) {
	199	disable_irq(data->irq);
	200	data->irq_enabled = false;
	201	}
ca3de46b SG	202	}
	203
	204	data->mode = mode;
	205	thermal_zone_device_update(tz);
	206
	207	return 0;
	208	}
	209
	210	static int imx_get_trip_type(struct thermal_zone_device *tz, int trip,
	211	enum thermal_trip_type *type)
	212	{
	213	*type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE :
	214	THERMAL_TRIP_CRITICAL;
	215	return 0;
	216	}
	217
	218	static int imx_get_crit_temp(struct thermal_zone_device *tz,
	219	unsigned long *temp)
	220	{
017e5142 PZ	221	struct imx_thermal_data *data = tz->devdata;
	222
	223	*temp = data->temp_critical;
ca3de46b SG	224	return 0;
	225	}
	226
	227	static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip,
	228	unsigned long *temp)
	229	{
017e5142 PZ	230	struct imx_thermal_data *data = tz->devdata;
	231
	232	*temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive :
	233	data->temp_critical;
	234	return 0;
	235	}
	236
	237	static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip,
	238	unsigned long temp)
	239	{
	240	struct imx_thermal_data *data = tz->devdata;
	241
	242	if (trip == IMX_TRIP_CRITICAL)
	243	return -EPERM;
	244
	245	if (temp > IMX_TEMP_PASSIVE)
	246	return -EINVAL;
	247
	248	data->temp_passive = temp;
	249
37713a1e PZ	250	imx_set_alarm_temp(data, temp);
37713a1e PZ	251
ca3de46b SG	252	return 0;
	253	}
	254
	255	static int imx_bind(struct thermal_zone_device *tz,
	256	struct thermal_cooling_device *cdev)
	257	{
	258	int ret;
	259
	260	ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev,
	261	THERMAL_NO_LIMIT,
	262	THERMAL_NO_LIMIT);
	263	if (ret) {
	264	dev_err(&tz->device,
	265	"binding zone %s with cdev %s failed:%d\n",
	266	tz->type, cdev->type, ret);
	267	return ret;
	268	}
	269
	270	return 0;
	271	}
	272
	273	static int imx_unbind(struct thermal_zone_device *tz,
	274	struct thermal_cooling_device *cdev)
	275	{
	276	int ret;
	277
	278	ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev);
	279	if (ret) {
	280	dev_err(&tz->device,
	281	"unbinding zone %s with cdev %s failed:%d\n",
	282	tz->type, cdev->type, ret);
	283	return ret;
	284	}
	285
	286	return 0;
	287	}
	288
cbb07bb3	289	static struct thermal_zone_device_ops imx_tz_ops = {
ca3de46b SG	290	.bind = imx_bind,
	291	.unbind = imx_unbind,
	292	.get_temp = imx_get_temp,
	293	.get_mode = imx_get_mode,
	294	.set_mode = imx_set_mode,
	295	.get_trip_type = imx_get_trip_type,
	296	.get_trip_temp = imx_get_trip_temp,
	297	.get_crit_temp = imx_get_crit_temp,
017e5142	298	.set_trip_temp = imx_set_trip_temp,
ca3de46b SG	299	};
	300
	301	static int imx_get_sensor_data(struct platform_device *pdev)
	302	{
	303	struct imx_thermal_data *data = platform_get_drvdata(pdev);
	304	struct regmap *map;
	305	int t1, t2, n1, n2;
	306	int ret;
	307	u32 val;
	308
	309	map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
	310	"fsl,tempmon-data");
	311	if (IS_ERR(map)) {
	312	ret = PTR_ERR(map);
	313	dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret);
	314	return ret;
	315	}
	316
	317	ret = regmap_read(map, OCOTP_ANA1, &val);
	318	if (ret) {
	319	dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret);
	320	return ret;
	321	}
	322
	323	if (val == 0 \|\| val == ~0) {
	324	dev_err(&pdev->dev, "invalid sensor calibration data\n");
	325	return -EINVAL;
	326	}
	327
	328	/*
	329	* Sensor data layout:
	330	* [31:20] - sensor value @ 25C
	331	* [19:8] - sensor value of hot
	332	* [7:0] - hot temperature value
	333	*/
	334	n1 = val >> 20;
	335	n2 = (val & 0xfff00) >> 8;
	336	t2 = val & 0xff;
	337	t1 = 25; /* t1 always 25C */
	338
	339	/*
	340	* Derived from linear interpolation,
	341	* Tmeas = T2 + (Nmeas - N2) * (T1 - T2) / (N1 - N2)
	342	* We want to reduce this down to the minimum computation necessary
	343	* for each temperature read. Also, we want Tmeas in millicelsius
	344	* and we don't want to lose precision from integer division. So...
	345	* milli_Tmeas = 1000 * T2 + 1000 * (Nmeas - N2) * (T1 - T2) / (N1 - N2)
	346	* Let constant c1 = 1000 * (T1 - T2) / (N1 - N2)
	347	* milli_Tmeas = (1000 * T2) + c1 * (Nmeas - N2)
	348	* milli_Tmeas = (1000 * T2) + (c1 * Nmeas) - (c1 * N2)
	349	* Let constant c2 = (1000 * T2) - (c1 * N2)
	350	* milli_Tmeas = c2 + (c1 * Nmeas)
	351	*/
	352	data->c1 = 1000 * (t1 - t2) / (n1 - n2);
	353	data->c2 = 1000 * t2 - data->c1 * n2;
	354
017e5142 PZ	355	/*
	356	* Set the default passive cooling trip point to 20 °C below the
	357	* maximum die temperature. Can be changed from userspace.
	358	*/
	359	data->temp_passive = 1000 * (t2 - 20);
	360
	361	/*
	362	* The maximum die temperature is t2, let's give 5 °C cushion
	363	* for noise and possible temperature rise between measurements.
	364	*/
	365	data->temp_critical = 1000 * (t2 - 5);
	366
ca3de46b SG	367	return 0;
	368	}
	369
37713a1e PZ	370	static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev)
	371	{
	372	struct imx_thermal_data *data = dev;
	373
	374	disable_irq_nosync(irq);
	375	data->irq_enabled = false;
	376
	377	return IRQ_WAKE_THREAD;
	378	}
	379
	380	static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev)
	381	{
	382	struct imx_thermal_data *data = dev;
	383
	384	dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n",
	385	data->alarm_temp / 1000);
	386
	387	thermal_zone_device_update(data->tz);
	388
	389	return IRQ_HANDLED;
	390	}
	391
ca3de46b SG	392	static int imx_thermal_probe(struct platform_device *pdev)
	393	{
	394	struct imx_thermal_data *data;
	395	struct cpumask clip_cpus;
	396	struct regmap *map;
37713a1e	397	int measure_freq;
ca3de46b SG	398	int ret;
	399
	400	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	401	if (!data)
	402	return -ENOMEM;
	403
	404	map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon");
	405	if (IS_ERR(map)) {
	406	ret = PTR_ERR(map);
	407	dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret);
	408	return ret;
	409	}
	410	data->tempmon = map;
	411
37713a1e PZ	412	data->irq = platform_get_irq(pdev, 0);
	413	if (data->irq < 0)
	414	return data->irq;
	415
	416	ret = devm_request_threaded_irq(&pdev->dev, data->irq,
	417	imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread,
	418	0, "imx_thermal", data);
	419	if (ret < 0) {
	420	dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
	421	return ret;
	422	}
	423
ca3de46b SG	424	platform_set_drvdata(pdev, data);
	425
	426	ret = imx_get_sensor_data(pdev);
	427	if (ret) {
	428	dev_err(&pdev->dev, "failed to get sensor data\n");
	429	return ret;
	430	}
	431
	432	/* Make sure sensor is in known good state for measurements */
	433	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	434	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	435	regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
	436	regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF);
	437	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	438
	439	cpumask_set_cpu(0, &clip_cpus);
	440	data->cdev = cpufreq_cooling_register(&clip_cpus);
	441	if (IS_ERR(data->cdev)) {
	442	ret = PTR_ERR(data->cdev);
	443	dev_err(&pdev->dev,
	444	"failed to register cpufreq cooling device: %d\n", ret);
	445	return ret;
	446	}
	447
	448	data->tz = thermal_zone_device_register("imx_thermal_zone",
017e5142 PZ	449	IMX_TRIP_NUM,
017e5142 PZ	450	BIT(IMX_TRIP_PASSIVE), data,
ca3de46b SG	451	&imx_tz_ops, NULL,
	452	IMX_PASSIVE_DELAY,
	453	IMX_POLLING_DELAY);
	454	if (IS_ERR(data->tz)) {
	455	ret = PTR_ERR(data->tz);
	456	dev_err(&pdev->dev,
	457	"failed to register thermal zone device %d\n", ret);
	458	cpufreq_cooling_unregister(data->cdev);
	459	return ret;
	460	}
	461
329fe7b1 AH	462	data->thermal_clk = devm_clk_get(&pdev->dev, NULL);
	463	if (IS_ERR(data->thermal_clk)) {
	464	dev_warn(&pdev->dev, "failed to get thermal clk!\n");
	465	} else {
	466	/*
	467	* Thermal sensor needs clk on to get correct value, normally
	468	* we should enable its clk before taking measurement and disable
	469	* clk after measurement is done, but if alarm function is enabled,
	470	* hardware will auto measure the temperature periodically, so we
	471	* need to keep the clk always on for alarm function.
	472	*/
	473	ret = clk_prepare_enable(data->thermal_clk);
	474	if (ret)
	475	dev_warn(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
	476	}
	477
37713a1e PZ	478	/* Enable measurements at ~ 10 Hz */
	479	regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
	480	measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */
	481	regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq);
	482	imx_set_alarm_temp(data, data->temp_passive);
	483	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	484	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
	485
	486	data->irq_enabled = true;
ca3de46b SG	487	data->mode = THERMAL_DEVICE_ENABLED;
	488
	489	return 0;
	490	}
	491
	492	static int imx_thermal_remove(struct platform_device *pdev)
	493	{
	494	struct imx_thermal_data *data = platform_get_drvdata(pdev);
37713a1e PZ	495	struct regmap *map = data->tempmon;
	496
	497	/* Disable measurements */
	498	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
329fe7b1 AH	499	if (!IS_ERR(data->thermal_clk))
329fe7b1 AH	500	clk_disable_unprepare(data->thermal_clk);
ca3de46b SG	501
	502	thermal_zone_device_unregister(data->tz);
	503	cpufreq_cooling_unregister(data->cdev);
	504
	505	return 0;
	506	}
	507
	508	#ifdef CONFIG_PM_SLEEP
	509	static int imx_thermal_suspend(struct device *dev)
	510	{
	511	struct imx_thermal_data *data = dev_get_drvdata(dev);
	512	struct regmap *map = data->tempmon;
ca3de46b	513
b46cce59 AH	514	/*
	515	* Need to disable thermal sensor, otherwise, when thermal core
	516	* try to get temperature before thermal sensor resume, a wrong
	517	* temperature will be read as the thermal sensor is powered
	518	* down.
	519	*/
	520	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
	521	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
	522	data->mode = THERMAL_DEVICE_DISABLED;
ca3de46b SG	523
	524	return 0;
	525	}
	526
	527	static int imx_thermal_resume(struct device *dev)
	528	{
b46cce59 AH	529	struct imx_thermal_data *data = dev_get_drvdata(dev);
	530	struct regmap *map = data->tempmon;
	531
	532	/* Enabled thermal sensor after resume */
	533	regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
	534	regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
	535	data->mode = THERMAL_DEVICE_ENABLED;
	536
ca3de46b SG	537	return 0;
	538	}
	539	#endif
	540
	541	static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops,
	542	imx_thermal_suspend, imx_thermal_resume);
	543
	544	static const struct of_device_id of_imx_thermal_match[] = {
	545	{ .compatible = "fsl,imx6q-tempmon", },
	546	{ /* end */ }
	547	};
dd268632	548	MODULE_DEVICE_TABLE(of, of_imx_thermal_match);
ca3de46b SG	549
	550	static struct platform_driver imx_thermal = {
	551	.driver = {
	552	.name = "imx_thermal",
	553	.owner = THIS_MODULE,
	554	.pm = &imx_thermal_pm_ops,
	555	.of_match_table = of_imx_thermal_match,
	556	},
	557	.probe = imx_thermal_probe,
	558	.remove = imx_thermal_remove,
	559	};
	560	module_platform_driver(imx_thermal);
	561
	562	MODULE_AUTHOR("Freescale Semiconductor, Inc.");
	563	MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs");
	564	MODULE_LICENSE("GPL v2");
	565	MODULE_ALIAS("platform:imx-thermal");