Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/thermal/imx_thermal.c

  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 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us