2 * Copyright 2013-2014 Freescale Semiconductor, Inc.
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.
10 #include <linux/clk.h>
11 #include <linux/cpu_cooling.h>
12 #include <linux/cpufreq.h>
13 #include <linux/delay.h>
14 #include <linux/device.h>
15 #include <linux/device_cooling.h>
16 #include <linux/init.h>
17 #include <linux/interrupt.h>
19 #include <linux/kernel.h>
20 #include <linux/mfd/syscon.h>
21 #include <linux/module.h>
23 #include <linux/of_device.h>
24 #include <linux/platform_device.h>
25 #include <linux/regmap.h>
26 #include <linux/slab.h>
27 #include <linux/thermal.h>
28 #include <linux/types.h>
35 #define MISC0_REFTOP_SELBIASOFF (1 << 3)
37 #define MISC1_IRQ_TEMPHIGH (1 << 29)
38 #define MISC1_IRQ_TEMPLOW (1 << 28)
39 #define MISC1_IRQ_TEMPPANIC (1 << 27)
41 #define TEMPSENSE0 0x0180
42 #define TEMPSENSE0_ALARM_VALUE_SHIFT 20
43 #define TEMPSENSE0_ALARM_VALUE_MASK (0xfff << TEMPSENSE0_ALARM_VALUE_SHIFT)
44 #define TEMPSENSE0_TEMP_CNT_SHIFT 8
45 #define TEMPSENSE0_TEMP_CNT_MASK (0xfff << TEMPSENSE0_TEMP_CNT_SHIFT)
46 #define TEMPSENSE0_FINISHED (1 << 2)
47 #define TEMPSENSE0_MEASURE_TEMP (1 << 1)
48 #define TEMPSENSE0_POWER_DOWN (1 << 0)
50 #define TEMPSENSE1 0x0190
51 #define TEMPSENSE1_MEASURE_FREQ 0xffff
52 #define TEMPSENSE2 0x0290
53 #define TEMPSENSE2_LOW_VALUE_SHIFT 0
54 #define TEMPSENSE2_LOW_VALUE_MASK 0xfff
55 #define TEMPSENSE2_PANIC_VALUE_SHIFT 16
56 #define TEMPSENSE2_PANIC_VALUE_MASK 0xfff0000
58 #define OCOTP_ANA1 0x04e0
60 /* The driver supports 1 passive trip point and 1 critical trip point */
61 enum imx_thermal_trip {
68 * It defines the temperature in millicelsius for passive trip point
69 * that will trigger cooling action when crossed.
71 #define IMX_TEMP_PASSIVE 85000
72 #define IMX_TEMP_PASSIVE_COOL_DELTA 10000
74 #define IMX_POLLING_DELAY 2000 /* millisecond */
75 #define IMX_PASSIVE_DELAY 1000
77 #define FACTOR0 10000000
79 #define FACTOR2 4297157
84 struct thermal_soc_data {
88 static struct thermal_soc_data thermal_imx6q_data = {
89 .version = TEMPMON_V1,
92 static struct thermal_soc_data thermal_imx6sx_data = {
93 .version = TEMPMON_V2,
96 struct imx_thermal_data {
97 struct thermal_zone_device *tz;
98 struct thermal_cooling_device *cdev[2];
99 enum thermal_device_mode mode;
100 struct regmap *tempmon;
101 u32 c1, c2; /* See formula in imx_get_sensor_data() */
102 unsigned long temp_passive;
103 unsigned long temp_critical;
104 unsigned long alarm_temp;
105 unsigned long last_temp;
108 struct clk *thermal_clk;
109 const struct thermal_soc_data *socdata;
112 static void imx_set_panic_temp(struct imx_thermal_data *data,
113 signed long panic_temp)
115 struct regmap *map = data->tempmon;
118 critical_value = (data->c2 - panic_temp) / data->c1;
119 regmap_write(map, TEMPSENSE2 + REG_CLR, TEMPSENSE2_PANIC_VALUE_MASK);
120 regmap_write(map, TEMPSENSE2 + REG_SET, critical_value <<
121 TEMPSENSE2_PANIC_VALUE_SHIFT);
124 static void imx_set_alarm_temp(struct imx_thermal_data *data,
125 signed long alarm_temp)
127 struct regmap *map = data->tempmon;
130 data->alarm_temp = alarm_temp;
131 alarm_value = (data->c2 - alarm_temp) / data->c1;
132 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_ALARM_VALUE_MASK);
133 regmap_write(map, TEMPSENSE0 + REG_SET, alarm_value <<
134 TEMPSENSE0_ALARM_VALUE_SHIFT);
137 static int imx_get_temp(struct thermal_zone_device *tz, unsigned long *temp)
139 struct imx_thermal_data *data = tz->devdata;
140 struct regmap *map = data->tempmon;
145 if (data->mode == THERMAL_DEVICE_ENABLED) {
146 /* Check if a measurement is currently in progress */
147 regmap_read(map, TEMPSENSE0, &val);
148 wait = !(val & TEMPSENSE0_FINISHED);
151 * Every time we measure the temperature, we will power on the
152 * temperature sensor, enable measurements, take a reading,
153 * disable measurements, power off the temperature sensor.
155 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
156 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
162 * According to the temp sensor designers, it may require up to ~17us
163 * to complete a measurement.
166 usleep_range(20, 50);
168 regmap_read(map, TEMPSENSE0, &val);
170 if (data->mode != THERMAL_DEVICE_ENABLED) {
171 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
172 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
175 if ((val & TEMPSENSE0_FINISHED) == 0) {
176 dev_dbg(&tz->device, "temp measurement never finished\n");
180 n_meas = (val & TEMPSENSE0_TEMP_CNT_MASK) >> TEMPSENSE0_TEMP_CNT_SHIFT;
182 /* See imx_get_sensor_data() for formula derivation */
183 *temp = data->c2 - n_meas * data->c1;
185 /* Update alarm value to next higher trip point */
186 if (data->alarm_temp == data->temp_passive && *temp >= data->temp_passive)
187 imx_set_alarm_temp(data, data->temp_critical);
188 if (data->alarm_temp == data->temp_critical && *temp < data->temp_passive) {
189 imx_set_alarm_temp(data, data->temp_passive);
190 dev_dbg(&tz->device, "thermal alarm off: T < %lu\n",
191 data->alarm_temp / 1000);
194 if (*temp != data->last_temp) {
195 dev_dbg(&tz->device, "millicelsius: %ld\n", *temp);
196 data->last_temp = *temp;
199 /* Reenable alarm IRQ if temperature below alarm temperature */
200 if (!data->irq_enabled && *temp < data->alarm_temp) {
201 data->irq_enabled = true;
202 enable_irq(data->irq);
208 static int imx_get_mode(struct thermal_zone_device *tz,
209 enum thermal_device_mode *mode)
211 struct imx_thermal_data *data = tz->devdata;
218 static int imx_set_mode(struct thermal_zone_device *tz,
219 enum thermal_device_mode mode)
221 struct imx_thermal_data *data = tz->devdata;
222 struct regmap *map = data->tempmon;
224 if (mode == THERMAL_DEVICE_ENABLED) {
225 tz->polling_delay = IMX_POLLING_DELAY;
226 tz->passive_delay = IMX_PASSIVE_DELAY;
228 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
229 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
231 if (!data->irq_enabled) {
232 data->irq_enabled = true;
233 enable_irq(data->irq);
236 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
237 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
239 tz->polling_delay = 0;
240 tz->passive_delay = 0;
242 if (data->irq_enabled) {
243 disable_irq(data->irq);
244 data->irq_enabled = false;
249 thermal_zone_device_update(tz);
254 static int imx_get_trip_type(struct thermal_zone_device *tz, int trip,
255 enum thermal_trip_type *type)
257 *type = (trip == IMX_TRIP_PASSIVE) ? THERMAL_TRIP_PASSIVE :
258 THERMAL_TRIP_CRITICAL;
262 static int imx_get_crit_temp(struct thermal_zone_device *tz,
265 struct imx_thermal_data *data = tz->devdata;
267 *temp = data->temp_critical;
271 static int imx_get_trip_temp(struct thermal_zone_device *tz, int trip,
274 struct imx_thermal_data *data = tz->devdata;
276 *temp = (trip == IMX_TRIP_PASSIVE) ? data->temp_passive :
281 static int imx_set_trip_temp(struct thermal_zone_device *tz, int trip,
284 struct imx_thermal_data *data = tz->devdata;
286 if (temp > IMX_TEMP_PASSIVE)
289 if (trip == IMX_TRIP_CRITICAL) {
290 data->temp_critical = temp;
291 if (data->socdata->version == TEMPMON_V2)
292 imx_set_panic_temp(data, temp);
295 if (trip == IMX_TRIP_PASSIVE) {
296 data->temp_passive = temp;
297 imx_set_alarm_temp(data, temp);
303 static int imx_get_trend(struct thermal_zone_device *tz,
304 int trip, enum thermal_trend *trend)
307 unsigned long trip_temp;
309 ret = imx_get_trip_temp(tz, trip, &trip_temp);
313 if (tz->temperature >= (trip_temp - IMX_TEMP_PASSIVE_COOL_DELTA))
314 *trend = THERMAL_TREND_RAISE_FULL;
316 *trend = THERMAL_TREND_DROP_FULL;
321 static int imx_bind(struct thermal_zone_device *tz,
322 struct thermal_cooling_device *cdev)
326 ret = thermal_zone_bind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev,
331 "binding zone %s with cdev %s failed:%d\n",
332 tz->type, cdev->type, ret);
339 static int imx_unbind(struct thermal_zone_device *tz,
340 struct thermal_cooling_device *cdev)
344 ret = thermal_zone_unbind_cooling_device(tz, IMX_TRIP_PASSIVE, cdev);
347 "unbinding zone %s with cdev %s failed:%d\n",
348 tz->type, cdev->type, ret);
355 static struct thermal_zone_device_ops imx_tz_ops = {
357 .unbind = imx_unbind,
358 .get_temp = imx_get_temp,
359 .get_mode = imx_get_mode,
360 .set_mode = imx_set_mode,
361 .get_trip_type = imx_get_trip_type,
362 .get_trip_temp = imx_get_trip_temp,
363 .get_crit_temp = imx_get_crit_temp,
364 .set_trip_temp = imx_set_trip_temp,
365 .get_trend = imx_get_trend,
368 static int imx_get_sensor_data(struct platform_device *pdev)
370 struct imx_thermal_data *data = platform_get_drvdata(pdev);
377 map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
381 dev_err(&pdev->dev, "failed to get sensor regmap: %d\n", ret);
385 ret = regmap_read(map, OCOTP_ANA1, &val);
387 dev_err(&pdev->dev, "failed to read sensor data: %d\n", ret);
391 if (val == 0 || val == ~0) {
392 dev_err(&pdev->dev, "invalid sensor calibration data\n");
397 * Sensor data layout:
398 * [31:20] - sensor value @ 25C
399 * [19:8] - sensor value of hot
400 * [7:0] - hot temperature value
401 * Use universal formula now and only need sensor value @ 25C
402 * slope = 0.4297157 - (0.0015976 * 25C fuse)
405 n2 = (val & 0xfff00) >> 8;
407 t1 = 25; /* t1 always 25C */
410 * Derived from linear interpolation:
411 * slope = 0.4297157 - (0.0015976 * 25C fuse)
412 * slope = (FACTOR2 - FACTOR1 * n1) / FACTOR0
413 * (Nmeas - n1) / (Tmeas - t1) = slope
414 * We want to reduce this down to the minimum computation necessary
415 * for each temperature read. Also, we want Tmeas in millicelsius
416 * and we don't want to lose precision from integer division. So...
417 * Tmeas = (Nmeas - n1) / slope + t1
418 * milli_Tmeas = 1000 * (Nmeas - n1) / slope + 1000 * t1
419 * milli_Tmeas = -1000 * (n1 - Nmeas) / slope + 1000 * t1
420 * Let constant c1 = (-1000 / slope)
421 * milli_Tmeas = (n1 - Nmeas) * c1 + 1000 * t1
422 * Let constant c2 = n1 *c1 + 1000 * t1
423 * milli_Tmeas = c2 - Nmeas * c1
427 do_div(temp64, FACTOR1 * n1 - FACTOR2);
429 data->c2 = n1 * data->c1 + 1000 * t1;
432 * Set the default passive cooling trip point to IMX_TEMP_PASSIVE.
433 * Can be changed from userspace.
435 data->temp_passive = IMX_TEMP_PASSIVE;
438 * Set the default critical trip point to 20 C higher
439 * than passive trip point. Can be changed from userspace.
441 data->temp_critical = IMX_TEMP_PASSIVE + 20 * 1000;
446 static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev)
448 struct imx_thermal_data *data = dev;
450 disable_irq_nosync(irq);
451 data->irq_enabled = false;
453 return IRQ_WAKE_THREAD;
456 static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev)
458 struct imx_thermal_data *data = dev;
460 dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n",
461 data->alarm_temp / 1000);
463 thermal_zone_device_update(data->tz);
468 static const struct of_device_id of_imx_thermal_match[] = {
469 { .compatible = "fsl,imx6q-tempmon", .data = &thermal_imx6q_data, },
470 { .compatible = "fsl,imx6sx-tempmon", .data = &thermal_imx6sx_data, },
473 MODULE_DEVICE_TABLE(of, of_imx_thermal_match);
475 static int imx_thermal_probe(struct platform_device *pdev)
477 const struct of_device_id *of_id =
478 of_match_device(of_imx_thermal_match, &pdev->dev);
479 struct imx_thermal_data *data;
480 struct cpumask clip_cpus;
485 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
489 map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon");
492 dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret);
497 data->socdata = of_id->data;
499 /* make sure the IRQ flag is clear before enable irq */
500 regmap_write(map, MISC1 + REG_CLR, MISC1_IRQ_TEMPHIGH);
501 if (data->socdata->version == TEMPMON_V2) {
502 regmap_write(map, MISC1 + REG_CLR, MISC1_IRQ_TEMPLOW |
503 MISC1_IRQ_TEMPPANIC);
505 * reset value of LOW ALARM is incorrect, set it to lowest
506 * value to avoid false trigger of low alarm.
508 regmap_write(map, TEMPSENSE2 + REG_SET,
509 TEMPSENSE2_LOW_VALUE_MASK);
512 data->irq = platform_get_irq(pdev, 0);
516 ret = devm_request_threaded_irq(&pdev->dev, data->irq,
517 imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread,
518 0, "imx_thermal", data);
520 dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
524 platform_set_drvdata(pdev, data);
526 ret = imx_get_sensor_data(pdev);
528 dev_err(&pdev->dev, "failed to get sensor data\n");
532 /* Make sure sensor is in known good state for measurements */
533 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
534 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
535 regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
536 regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF);
537 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
539 cpumask_set_cpu(0, &clip_cpus);
540 data->cdev[0] = cpufreq_cooling_register(&clip_cpus);
541 if (IS_ERR(data->cdev[0])) {
542 ret = PTR_ERR(data->cdev[0]);
544 "failed to register cpufreq cooling device: %d\n", ret);
548 data->cdev[1] = devfreq_cooling_register();
549 if (IS_ERR(data->cdev[1])) {
550 ret = PTR_ERR(data->cdev[1]);
552 "failed to register devfreq cooling device: %d\n", ret);
556 data->tz = thermal_zone_device_register("imx_thermal_zone",
558 (1 << IMX_TRIP_NUM) - 1, data,
562 if (IS_ERR(data->tz)) {
563 ret = PTR_ERR(data->tz);
565 "failed to register thermal zone device %d\n", ret);
566 cpufreq_cooling_unregister(data->cdev[0]);
567 devfreq_cooling_unregister(data->cdev[1]);
571 data->thermal_clk = devm_clk_get(&pdev->dev, NULL);
572 if (IS_ERR(data->thermal_clk)) {
573 dev_warn(&pdev->dev, "failed to get thermal clk!\n");
576 * Thermal sensor needs clk on to get correct value, normally
577 * we should enable its clk before taking measurement and disable
578 * clk after measurement is done, but if alarm function is enabled,
579 * hardware will auto measure the temperature periodically, so we
580 * need to keep the clk always on for alarm function.
582 ret = clk_prepare_enable(data->thermal_clk);
584 dev_warn(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
587 /* Enable measurements at ~ 10 Hz */
588 regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
589 measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */
590 regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq);
591 imx_set_alarm_temp(data, data->temp_passive);
593 if (data->socdata->version == TEMPMON_V2)
594 imx_set_panic_temp(data, data->temp_critical);
596 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
597 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
599 data->irq_enabled = true;
600 data->mode = THERMAL_DEVICE_ENABLED;
605 static int imx_thermal_remove(struct platform_device *pdev)
607 struct imx_thermal_data *data = platform_get_drvdata(pdev);
608 struct regmap *map = data->tempmon;
610 /* Disable measurements */
611 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
612 if (!IS_ERR(data->thermal_clk))
613 clk_disable_unprepare(data->thermal_clk);
615 thermal_zone_device_unregister(data->tz);
616 cpufreq_cooling_unregister(data->cdev[0]);
617 devfreq_cooling_unregister(data->cdev[1]);
622 #ifdef CONFIG_PM_SLEEP
623 static int imx_thermal_suspend(struct device *dev)
625 struct imx_thermal_data *data = dev_get_drvdata(dev);
626 struct regmap *map = data->tempmon;
629 * Need to disable thermal sensor, otherwise, when thermal core
630 * try to get temperature before thermal sensor resume, a wrong
631 * temperature will be read as the thermal sensor is powered
634 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
635 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
636 data->mode = THERMAL_DEVICE_DISABLED;
637 disable_irq(data->irq);
638 clk_disable_unprepare(data->thermal_clk);
643 static int imx_thermal_resume(struct device *dev)
645 struct imx_thermal_data *data = dev_get_drvdata(dev);
646 struct regmap *map = data->tempmon;
648 /* Enabled thermal sensor after resume */
649 regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
650 regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
651 data->mode = THERMAL_DEVICE_ENABLED;
652 clk_prepare_enable(data->thermal_clk);
653 enable_irq(data->irq);
659 static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops,
660 imx_thermal_suspend, imx_thermal_resume);
662 static struct platform_driver imx_thermal = {
664 .name = "imx_thermal",
665 .owner = THIS_MODULE,
666 .pm = &imx_thermal_pm_ops,
667 .of_match_table = of_imx_thermal_match,
669 .probe = imx_thermal_probe,
670 .remove = imx_thermal_remove,
673 static int __init imx_thermal_init(void)
675 return platform_driver_register(&imx_thermal);
678 late_initcall(imx_thermal_init);
680 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
681 MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs");
682 MODULE_LICENSE("GPL v2");
683 MODULE_ALIAS("platform:imx-thermal");