Version:  2.0.40 2.2.26 2.4.37 2.6.39 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

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, t2, n1, n2;
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          *    [19:8] - sensor value of hot
337          *     [7:0] - hot temperature value
338          * Use universal formula now and only need sensor value @ 25C
339          * slope = 0.4297157 - (0.0015976 * 25C fuse)
340          */
341         n1 = val >> 20;
342         n2 = (val & 0xfff00) >> 8;
343         t2 = val & 0xff;
344         t1 = 25; /* t1 always 25C */
345 
346         /*
347          * Derived from linear interpolation:
348          * slope = 0.4297157 - (0.0015976 * 25C fuse)
349          * slope = (FACTOR2 - FACTOR1 * n1) / FACTOR0
350          * (Nmeas - n1) / (Tmeas - t1) = slope
351          * We want to reduce this down to the minimum computation necessary
352          * for each temperature read.  Also, we want Tmeas in millicelsius
353          * and we don't want to lose precision from integer division. So...
354          * Tmeas = (Nmeas - n1) / slope + t1
355          * milli_Tmeas = 1000 * (Nmeas - n1) / slope + 1000 * t1
356          * milli_Tmeas = -1000 * (n1 - Nmeas) / slope + 1000 * t1
357          * Let constant c1 = (-1000 / slope)
358          * milli_Tmeas = (n1 - Nmeas) * c1 + 1000 * t1
359          * Let constant c2 = n1 *c1 + 1000 * t1
360          * milli_Tmeas = c2 - Nmeas * c1
361          */
362         temp64 = FACTOR0;
363         temp64 *= 1000;
364         do_div(temp64, FACTOR1 * n1 - FACTOR2);
365         data->c1 = temp64;
366         data->c2 = n1 * data->c1 + 1000 * t1;
367 
368         /*
369          * Set the default passive cooling trip point to 20 °C below the
370          * maximum die temperature. Can be changed from userspace.
371          */
372         data->temp_passive = 1000 * (t2 - 20);
373 
374         /*
375          * The maximum die temperature is t2, let's give 5 °C cushion
376          * for noise and possible temperature rise between measurements.
377          */
378         data->temp_critical = 1000 * (t2 - 5);
379 
380         return 0;
381 }
382 
383 static irqreturn_t imx_thermal_alarm_irq(int irq, void *dev)
384 {
385         struct imx_thermal_data *data = dev;
386 
387         disable_irq_nosync(irq);
388         data->irq_enabled = false;
389 
390         return IRQ_WAKE_THREAD;
391 }
392 
393 static irqreturn_t imx_thermal_alarm_irq_thread(int irq, void *dev)
394 {
395         struct imx_thermal_data *data = dev;
396 
397         dev_dbg(&data->tz->device, "THERMAL ALARM: T > %lu\n",
398                 data->alarm_temp / 1000);
399 
400         thermal_zone_device_update(data->tz);
401 
402         return IRQ_HANDLED;
403 }
404 
405 static int imx_thermal_probe(struct platform_device *pdev)
406 {
407         struct imx_thermal_data *data;
408         struct cpumask clip_cpus;
409         struct regmap *map;
410         int measure_freq;
411         int ret;
412 
413         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
414         if (!data)
415                 return -ENOMEM;
416 
417         map = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "fsl,tempmon");
418         if (IS_ERR(map)) {
419                 ret = PTR_ERR(map);
420                 dev_err(&pdev->dev, "failed to get tempmon regmap: %d\n", ret);
421                 return ret;
422         }
423         data->tempmon = map;
424 
425         data->irq = platform_get_irq(pdev, 0);
426         if (data->irq < 0)
427                 return data->irq;
428 
429         ret = devm_request_threaded_irq(&pdev->dev, data->irq,
430                         imx_thermal_alarm_irq, imx_thermal_alarm_irq_thread,
431                         0, "imx_thermal", data);
432         if (ret < 0) {
433                 dev_err(&pdev->dev, "failed to request alarm irq: %d\n", ret);
434                 return ret;
435         }
436 
437         platform_set_drvdata(pdev, data);
438 
439         ret = imx_get_sensor_data(pdev);
440         if (ret) {
441                 dev_err(&pdev->dev, "failed to get sensor data\n");
442                 return ret;
443         }
444 
445         /* Make sure sensor is in known good state for measurements */
446         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
447         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
448         regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
449         regmap_write(map, MISC0 + REG_SET, MISC0_REFTOP_SELBIASOFF);
450         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
451 
452         cpumask_set_cpu(0, &clip_cpus);
453         data->cdev = cpufreq_cooling_register(&clip_cpus);
454         if (IS_ERR(data->cdev)) {
455                 ret = PTR_ERR(data->cdev);
456                 dev_err(&pdev->dev,
457                         "failed to register cpufreq cooling device: %d\n", ret);
458                 return ret;
459         }
460 
461         data->tz = thermal_zone_device_register("imx_thermal_zone",
462                                                 IMX_TRIP_NUM,
463                                                 BIT(IMX_TRIP_PASSIVE), data,
464                                                 &imx_tz_ops, NULL,
465                                                 IMX_PASSIVE_DELAY,
466                                                 IMX_POLLING_DELAY);
467         if (IS_ERR(data->tz)) {
468                 ret = PTR_ERR(data->tz);
469                 dev_err(&pdev->dev,
470                         "failed to register thermal zone device %d\n", ret);
471                 cpufreq_cooling_unregister(data->cdev);
472                 return ret;
473         }
474 
475         data->thermal_clk = devm_clk_get(&pdev->dev, NULL);
476         if (IS_ERR(data->thermal_clk)) {
477                 dev_warn(&pdev->dev, "failed to get thermal clk!\n");
478         } else {
479                 /*
480                  * Thermal sensor needs clk on to get correct value, normally
481                  * we should enable its clk before taking measurement and disable
482                  * clk after measurement is done, but if alarm function is enabled,
483                  * hardware will auto measure the temperature periodically, so we
484                  * need to keep the clk always on for alarm function.
485                  */
486                 ret = clk_prepare_enable(data->thermal_clk);
487                 if (ret)
488                         dev_warn(&pdev->dev, "failed to enable thermal clk: %d\n", ret);
489         }
490 
491         /* Enable measurements at ~ 10 Hz */
492         regmap_write(map, TEMPSENSE1 + REG_CLR, TEMPSENSE1_MEASURE_FREQ);
493         measure_freq = DIV_ROUND_UP(32768, 10); /* 10 Hz */
494         regmap_write(map, TEMPSENSE1 + REG_SET, measure_freq);
495         imx_set_alarm_temp(data, data->temp_passive);
496         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
497         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
498 
499         data->irq_enabled = true;
500         data->mode = THERMAL_DEVICE_ENABLED;
501 
502         return 0;
503 }
504 
505 static int imx_thermal_remove(struct platform_device *pdev)
506 {
507         struct imx_thermal_data *data = platform_get_drvdata(pdev);
508         struct regmap *map = data->tempmon;
509 
510         /* Disable measurements */
511         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
512         if (!IS_ERR(data->thermal_clk))
513                 clk_disable_unprepare(data->thermal_clk);
514 
515         thermal_zone_device_unregister(data->tz);
516         cpufreq_cooling_unregister(data->cdev);
517 
518         return 0;
519 }
520 
521 #ifdef CONFIG_PM_SLEEP
522 static int imx_thermal_suspend(struct device *dev)
523 {
524         struct imx_thermal_data *data = dev_get_drvdata(dev);
525         struct regmap *map = data->tempmon;
526 
527         /*
528          * Need to disable thermal sensor, otherwise, when thermal core
529          * try to get temperature before thermal sensor resume, a wrong
530          * temperature will be read as the thermal sensor is powered
531          * down.
532          */
533         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_MEASURE_TEMP);
534         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_POWER_DOWN);
535         data->mode = THERMAL_DEVICE_DISABLED;
536 
537         return 0;
538 }
539 
540 static int imx_thermal_resume(struct device *dev)
541 {
542         struct imx_thermal_data *data = dev_get_drvdata(dev);
543         struct regmap *map = data->tempmon;
544 
545         /* Enabled thermal sensor after resume */
546         regmap_write(map, TEMPSENSE0 + REG_CLR, TEMPSENSE0_POWER_DOWN);
547         regmap_write(map, TEMPSENSE0 + REG_SET, TEMPSENSE0_MEASURE_TEMP);
548         data->mode = THERMAL_DEVICE_ENABLED;
549 
550         return 0;
551 }
552 #endif
553 
554 static SIMPLE_DEV_PM_OPS(imx_thermal_pm_ops,
555                          imx_thermal_suspend, imx_thermal_resume);
556 
557 static const struct of_device_id of_imx_thermal_match[] = {
558         { .compatible = "fsl,imx6q-tempmon", },
559         { /* end */ }
560 };
561 MODULE_DEVICE_TABLE(of, of_imx_thermal_match);
562 
563 static struct platform_driver imx_thermal = {
564         .driver = {
565                 .name   = "imx_thermal",
566                 .owner  = THIS_MODULE,
567                 .pm     = &imx_thermal_pm_ops,
568                 .of_match_table = of_imx_thermal_match,
569         },
570         .probe          = imx_thermal_probe,
571         .remove         = imx_thermal_remove,
572 };
573 module_platform_driver(imx_thermal);
574 
575 MODULE_AUTHOR("Freescale Semiconductor, Inc.");
576 MODULE_DESCRIPTION("Thermal driver for Freescale i.MX SoCs");
577 MODULE_LICENSE("GPL v2");
578 MODULE_ALIAS("platform:imx-thermal");
579 

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