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