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/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");