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