drivers/thermal/st/stm_thermal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
   4  * Author: David Hernandez Sanchez <david.hernandezsanchez@st.com> for
   5  * STMicroelectronics.
   6  */
   7
   8 #include <linux/clk.h>
   9 #include <linux/clk-provider.h>
  10 #include <linux/delay.h>
  11 #include <linux/err.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/io.h>
  14 #include <linux/iopoll.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_address.h>
  18 #include <linux/of_device.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/thermal.h>
  21
  22 #include "../thermal_core.h"
  23 #include "../thermal_hwmon.h"
  24
  25 /* DTS register offsets */
  26 #define DTS_CFGR1_OFFSET        0x0
  27 #define DTS_T0VALR1_OFFSET      0x8
  28 #define DTS_RAMPVALR_OFFSET     0X10
  29 #define DTS_ITR1_OFFSET         0x14
  30 #define DTS_DR_OFFSET           0x1C
  31 #define DTS_SR_OFFSET           0x20
  32 #define DTS_ITENR_OFFSET        0x24
  33 #define DTS_ICIFR_OFFSET        0x28
  34
  35 /* DTS_CFGR1 register mask definitions */
  36 #define HSREF_CLK_DIV_MASK      GENMASK(30, 24)
  37 #define TS1_SMP_TIME_MASK       GENMASK(19, 16)
  38 #define TS1_INTRIG_SEL_MASK     GENMASK(11, 8)
  39
  40 /* DTS_T0VALR1 register mask definitions */
  41 #define TS1_T0_MASK             GENMASK(17, 16)
  42 #define TS1_FMT0_MASK           GENMASK(15, 0)
  43
  44 /* DTS_RAMPVALR register mask definitions */
  45 #define TS1_RAMP_COEFF_MASK     GENMASK(15, 0)
  46
  47 /* DTS_ITR1 register mask definitions */
  48 #define TS1_HITTHD_MASK         GENMASK(31, 16)
  49 #define TS1_LITTHD_MASK         GENMASK(15, 0)
  50
  51 /* DTS_DR register mask definitions */
  52 #define TS1_MFREQ_MASK          GENMASK(15, 0)
  53
  54 /* DTS_ITENR register mask definitions */
  55 #define ITENR_MASK              (GENMASK(2, 0) | GENMASK(6, 4))
  56
  57 /* DTS_ICIFR register mask definitions */
  58 #define ICIFR_MASK              (GENMASK(2, 0) | GENMASK(6, 4))
  59
  60 /* Less significant bit position definitions */
  61 #define TS1_T0_POS              16
  62 #define TS1_HITTHD_POS          16
  63 #define TS1_LITTHD_POS          0
  64 #define HSREF_CLK_DIV_POS       24
  65
  66 /* DTS_CFGR1 bit definitions */
  67 #define TS1_EN                  BIT(0)
  68 #define TS1_START               BIT(4)
  69 #define REFCLK_SEL              BIT(20)
  70 #define REFCLK_LSE              REFCLK_SEL
  71 #define Q_MEAS_OPT              BIT(21)
  72 #define CALIBRATION_CONTROL     Q_MEAS_OPT
  73
  74 /* DTS_SR bit definitions */
  75 #define TS_RDY                  BIT(15)
  76 /* Bit definitions below are common for DTS_SR, DTS_ITENR and DTS_CIFR */
  77 #define HIGH_THRESHOLD          BIT(2)
  78 #define LOW_THRESHOLD           BIT(1)
  79
  80 /* Constants */
  81 #define ADJUST                  100
  82 #define ONE_MHZ                 1000000
  83 #define POLL_TIMEOUT            5000
  84 #define STARTUP_TIME            40
  85 #define TS1_T0_VAL0             30000  /* 30 celsius */
  86 #define TS1_T0_VAL1             130000 /* 130 celsius */
  87 #define NO_HW_TRIG              0
  88 #define SAMPLING_TIME           15
  89
  90 struct stm_thermal_sensor {
  91         struct device *dev;
  92         struct thermal_zone_device *th_dev;
  93         enum thermal_device_mode mode;
  94         struct clk *clk;
  95         unsigned int low_temp_enabled;
  96         unsigned int high_temp_enabled;
  97         int irq;
  98         void __iomem *base;
  99         int t0, fmt0, ramp_coeff;
 100 };
 101
 102 static int stm_enable_irq(struct stm_thermal_sensor *sensor)
 103 {
 104         u32 value;
 105
 106         dev_dbg(sensor->dev, "low:%d high:%d\n", sensor->low_temp_enabled,
 107                 sensor->high_temp_enabled);
 108
 109         /* Disable IT generation for low and high thresholds */
 110         value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
 111         value &= ~(LOW_THRESHOLD | HIGH_THRESHOLD);
 112
 113         if (sensor->low_temp_enabled)
 114                 value |= HIGH_THRESHOLD;
 115
 116         if (sensor->high_temp_enabled)
 117                 value |= LOW_THRESHOLD;
 118
 119         /* Enable interrupts */
 120         writel_relaxed(value, sensor->base + DTS_ITENR_OFFSET);
 121
 122         return 0;
 123 }
 124
 125 static irqreturn_t stm_thermal_irq_handler(int irq, void *sdata)
 126 {
 127         struct stm_thermal_sensor *sensor = sdata;
 128
 129         dev_dbg(sensor->dev, "sr:%d\n",
 130                 readl_relaxed(sensor->base + DTS_SR_OFFSET));
 131
 132         thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
 133
 134         stm_enable_irq(sensor);
 135
 136         /* Acknoledge all DTS irqs */
 137         writel_relaxed(ICIFR_MASK, sensor->base + DTS_ICIFR_OFFSET);
 138
 139         return IRQ_HANDLED;
 140 }
 141
 142 static int stm_sensor_power_on(struct stm_thermal_sensor *sensor)
 143 {
 144         int ret;
 145         u32 value;
 146
 147         /* Enable sensor */
 148         value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
 149         value |= TS1_EN;
 150         writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
 151
 152         /*
 153          * The DTS block can be enabled by setting TSx_EN bit in
 154          * DTS_CFGRx register. It requires a startup time of
 155          * 40μs. Use 5 ms as arbitrary timeout.
 156          */
 157         ret = readl_poll_timeout(sensor->base + DTS_SR_OFFSET,
 158                                  value, (value & TS_RDY),
 159                                  STARTUP_TIME, POLL_TIMEOUT);
 160         if (ret)
 161                 return ret;
 162
 163         /* Start continuous measuring */
 164         value = readl_relaxed(sensor->base +
 165                               DTS_CFGR1_OFFSET);
 166         value |= TS1_START;
 167         writel_relaxed(value, sensor->base +
 168                        DTS_CFGR1_OFFSET);
 169
 170         sensor->mode = THERMAL_DEVICE_ENABLED;
 171
 172         return 0;
 173 }
 174
 175 static int stm_sensor_power_off(struct stm_thermal_sensor *sensor)
 176 {
 177         u32 value;
 178
 179         sensor->mode = THERMAL_DEVICE_DISABLED;
 180
 181         /* Stop measuring */
 182         value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
 183         value &= ~TS1_START;
 184         writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
 185
 186         /* Ensure stop is taken into account */
 187         usleep_range(STARTUP_TIME, POLL_TIMEOUT);
 188
 189         /* Disable sensor */
 190         value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
 191         value &= ~TS1_EN;
 192         writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
 193
 194         /* Ensure disable is taken into account */
 195         return readl_poll_timeout(sensor->base + DTS_SR_OFFSET, value,
 196                                   !(value & TS_RDY),
 197                                   STARTUP_TIME, POLL_TIMEOUT);
 198 }
 199
 200 static int stm_thermal_calibration(struct stm_thermal_sensor *sensor)
 201 {
 202         u32 value, clk_freq;
 203         u32 prescaler;
 204
 205         /* Figure out prescaler value for PCLK during calibration */
 206         clk_freq = clk_get_rate(sensor->clk);
 207         if (!clk_freq)
 208                 return -EINVAL;
 209
 210         prescaler = 0;
 211         clk_freq /= ONE_MHZ;
 212         if (clk_freq) {
 213                 while (prescaler <= clk_freq)
 214                         prescaler++;
 215         }
 216
 217         value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
 218
 219         /* Clear prescaler */
 220         value &= ~HSREF_CLK_DIV_MASK;
 221
 222         /* Set prescaler. pclk_freq/prescaler < 1MHz */
 223         value |= (prescaler << HSREF_CLK_DIV_POS);
 224
 225         /* Select PCLK as reference clock */
 226         value &= ~REFCLK_SEL;
 227
 228         /* Set maximal sampling time for better precision */
 229         value |= TS1_SMP_TIME_MASK;
 230
 231         /* Measure with calibration */
 232         value &= ~CALIBRATION_CONTROL;
 233
 234         /* select trigger */
 235         value &= ~TS1_INTRIG_SEL_MASK;
 236         value |= NO_HW_TRIG;
 237
 238         writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
 239
 240         return 0;
 241 }
 242
 243 /* Fill in DTS structure with factory sensor values */
 244 static int stm_thermal_read_factory_settings(struct stm_thermal_sensor *sensor)
 245 {
 246         /* Retrieve engineering calibration temperature */
 247         sensor->t0 = readl_relaxed(sensor->base + DTS_T0VALR1_OFFSET) &
 248                                         TS1_T0_MASK;
 249         if (!sensor->t0)
 250                 sensor->t0 = TS1_T0_VAL0;
 251         else
 252                 sensor->t0 = TS1_T0_VAL1;
 253
 254         /* Retrieve fmt0 and put it on Hz */
 255         sensor->fmt0 = ADJUST * (readl_relaxed(sensor->base +
 256                                  DTS_T0VALR1_OFFSET) & TS1_FMT0_MASK);
 257
 258         /* Retrieve ramp coefficient */
 259         sensor->ramp_coeff = readl_relaxed(sensor->base + DTS_RAMPVALR_OFFSET) &
 260                                            TS1_RAMP_COEFF_MASK;
 261
 262         if (!sensor->fmt0 || !sensor->ramp_coeff) {
 263                 dev_err(sensor->dev, "%s: wrong setting\n", __func__);
 264                 return -EINVAL;
 265         }
 266
 267         dev_dbg(sensor->dev, "%s: T0 = %doC, FMT0 = %dHz, RAMP_COEFF = %dHz/oC",
 268                 __func__, sensor->t0, sensor->fmt0, sensor->ramp_coeff);
 269
 270         return 0;
 271 }
 272
 273 static int stm_thermal_calculate_threshold(struct stm_thermal_sensor *sensor,
 274                                            int temp, u32 *th)
 275 {
 276         int freqM;
 277
 278         /* Figure out the CLK_PTAT frequency for a given temperature */
 279         freqM = ((temp - sensor->t0) * sensor->ramp_coeff) / 1000 +
 280                 sensor->fmt0;
 281
 282         /* Figure out the threshold sample number */
 283         *th = clk_get_rate(sensor->clk) * SAMPLING_TIME / freqM;
 284         if (!*th)
 285                 return -EINVAL;
 286
 287         dev_dbg(sensor->dev, "freqM=%d Hz, threshold=0x%x", freqM, *th);
 288
 289         return 0;
 290 }
 291
 292 /* Disable temperature interrupt */
 293 static int stm_disable_irq(struct stm_thermal_sensor *sensor)
 294 {
 295         u32 value;
 296
 297         /* Disable IT generation */
 298         value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
 299         value &= ~ITENR_MASK;
 300         writel_relaxed(value, sensor->base + DTS_ITENR_OFFSET);
 301
 302         return 0;
 303 }
 304
 305 static int stm_thermal_set_trips(void *data, int low, int high)
 306 {
 307         struct stm_thermal_sensor *sensor = data;
 308         u32 itr1, th;
 309         int ret;
 310
 311         dev_dbg(sensor->dev, "set trips %d <--> %d\n", low, high);
 312
 313         /* Erase threshold content */
 314         itr1 = readl_relaxed(sensor->base + DTS_ITR1_OFFSET);
 315         itr1 &= ~(TS1_LITTHD_MASK | TS1_HITTHD_MASK);
 316
 317         /*
 318          * Disable low-temp if "low" is too small. As per thermal framework
 319          * API, we use -INT_MAX rather than INT_MIN.
 320          */
 321
 322         if (low > -INT_MAX) {
 323                 sensor->low_temp_enabled = 1;
 324                 /* add 0.5 of hysteresis due to measurement error */
 325                 ret = stm_thermal_calculate_threshold(sensor, low - 500, &th);
 326                 if (ret)
 327                         return ret;
 328
 329                 itr1 |= (TS1_HITTHD_MASK  & (th << TS1_HITTHD_POS));
 330         } else {
 331                 sensor->low_temp_enabled = 0;
 332         }
 333
 334         /* Disable high-temp if "high" is too big. */
 335         if (high < INT_MAX) {
 336                 sensor->high_temp_enabled = 1;
 337                 ret = stm_thermal_calculate_threshold(sensor, high, &th);
 338                 if (ret)
 339                         return ret;
 340
 341                 itr1 |= (TS1_LITTHD_MASK  & (th << TS1_LITTHD_POS));
 342         } else {
 343                 sensor->high_temp_enabled = 0;
 344         }
 345
 346         /* Write new threshod values*/
 347         writel_relaxed(itr1, sensor->base + DTS_ITR1_OFFSET);
 348
 349         return 0;
 350 }
 351
 352 /* Callback to get temperature from HW */
 353 static int stm_thermal_get_temp(void *data, int *temp)
 354 {
 355         struct stm_thermal_sensor *sensor = data;
 356         u32 periods;
 357         int freqM, ret;
 358
 359         if (sensor->mode != THERMAL_DEVICE_ENABLED)
 360                 return -EAGAIN;
 361
 362         /* Retrieve the number of periods sampled */
 363         ret = readl_relaxed_poll_timeout(sensor->base + DTS_DR_OFFSET, periods,
 364                                          (periods & TS1_MFREQ_MASK),
 365                                          STARTUP_TIME, POLL_TIMEOUT);
 366         if (ret)
 367                 return ret;
 368
 369         /* Figure out the CLK_PTAT frequency */
 370         freqM = (clk_get_rate(sensor->clk) * SAMPLING_TIME) / periods;
 371         if (!freqM)
 372                 return -EINVAL;
 373
 374         /* Figure out the temperature in mili celsius */
 375         *temp = (freqM - sensor->fmt0) * 1000 / sensor->ramp_coeff + sensor->t0;
 376
 377         return 0;
 378 }
 379
 380 /* Registers DTS irq to be visible by GIC */
 381 static int stm_register_irq(struct stm_thermal_sensor *sensor)
 382 {
 383         struct device *dev = sensor->dev;
 384         struct platform_device *pdev = to_platform_device(dev);
 385         int ret;
 386
 387         sensor->irq = platform_get_irq(pdev, 0);
 388         if (sensor->irq < 0) {
 389                 dev_err(dev, "%s: Unable to find IRQ\n", __func__);
 390                 return sensor->irq;
 391         }
 392
 393         ret = devm_request_threaded_irq(dev, sensor->irq,
 394                                         NULL,
 395                                         stm_thermal_irq_handler,
 396                                         IRQF_ONESHOT,
 397                                         dev->driver->name, sensor);
 398         if (ret) {
 399                 dev_err(dev, "%s: Failed to register IRQ %d\n", __func__,
 400                         sensor->irq);
 401                 return ret;
 402         }
 403
 404         dev_dbg(dev, "%s: thermal IRQ registered", __func__);
 405
 406         return 0;
 407 }
 408
 409 static int stm_thermal_sensor_off(struct stm_thermal_sensor *sensor)
 410 {
 411         int ret;
 412
 413         stm_disable_irq(sensor);
 414
 415         ret = stm_sensor_power_off(sensor);
 416         if (ret)
 417                 return ret;
 418
 419         clk_disable_unprepare(sensor->clk);
 420
 421         return 0;
 422 }
 423
 424 static int stm_thermal_prepare(struct stm_thermal_sensor *sensor)
 425 {
 426         int ret;
 427
 428         ret = clk_prepare_enable(sensor->clk);
 429         if (ret)
 430                 return ret;
 431
 432         ret = stm_thermal_read_factory_settings(sensor);
 433         if (ret)
 434                 goto thermal_unprepare;
 435
 436         ret = stm_thermal_calibration(sensor);
 437         if (ret)
 438                 goto thermal_unprepare;
 439
 440         return 0;
 441
 442 thermal_unprepare:
 443         clk_disable_unprepare(sensor->clk);
 444
 445         return ret;
 446 }
 447
 448 #ifdef CONFIG_PM_SLEEP
 449 static int stm_thermal_suspend(struct device *dev)
 450 {
 451         int ret;
 452         struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
 453
 454         ret = stm_thermal_sensor_off(sensor);
 455         if (ret)
 456                 return ret;
 457
 458         return 0;
 459 }
 460
 461 static int stm_thermal_resume(struct device *dev)
 462 {
 463         int ret;
 464         struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
 465
 466         ret = stm_thermal_prepare(sensor);
 467         if (ret)
 468                 return ret;
 469
 470         ret = stm_sensor_power_on(sensor);
 471         if (ret)
 472                 return ret;
 473
 474         thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
 475         stm_enable_irq(sensor);
 476
 477         return 0;
 478 }
 479 #endif /* CONFIG_PM_SLEEP */
 480
 481 SIMPLE_DEV_PM_OPS(stm_thermal_pm_ops, stm_thermal_suspend, stm_thermal_resume);
 482
 483 static const struct thermal_zone_of_device_ops stm_tz_ops = {
 484         .get_temp       = stm_thermal_get_temp,
 485         .set_trips      = stm_thermal_set_trips,
 486 };
 487
 488 static const struct of_device_id stm_thermal_of_match[] = {
 489                 { .compatible = "st,stm32-thermal"},
 490         { /* sentinel */ }
 491 };
 492 MODULE_DEVICE_TABLE(of, stm_thermal_of_match);
 493
 494 static int stm_thermal_probe(struct platform_device *pdev)
 495 {
 496         struct stm_thermal_sensor *sensor;
 497         struct resource *res;
 498         void __iomem *base;
 499         int ret;
 500
 501         if (!pdev->dev.of_node) {
 502                 dev_err(&pdev->dev, "%s: device tree node not found\n",
 503                         __func__);
 504                 return -EINVAL;
 505         }
 506
 507         sensor = devm_kzalloc(&pdev->dev, sizeof(*sensor), GFP_KERNEL);
 508         if (!sensor)
 509                 return -ENOMEM;
 510
 511         platform_set_drvdata(pdev, sensor);
 512
 513         sensor->dev = &pdev->dev;
 514
 515         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 516         base = devm_ioremap_resource(&pdev->dev, res);
 517         if (IS_ERR(base))
 518                 return PTR_ERR(base);
 519
 520         /* Populate sensor */
 521         sensor->base = base;
 522
 523         sensor->clk = devm_clk_get(&pdev->dev, "pclk");
 524         if (IS_ERR(sensor->clk)) {
 525                 dev_err(&pdev->dev, "%s: failed to fetch PCLK clock\n",
 526                         __func__);
 527                 return PTR_ERR(sensor->clk);
 528         }
 529
 530         stm_disable_irq(sensor);
 531
 532         /* Clear irq flags */
 533         writel_relaxed(ICIFR_MASK, sensor->base + DTS_ICIFR_OFFSET);
 534
 535         /* Configure and enable HW sensor */
 536         ret = stm_thermal_prepare(sensor);
 537         if (ret) {
 538                 dev_err(&pdev->dev, "Error prepare sensor: %d\n", ret);
 539                 return ret;
 540         }
 541
 542         ret = stm_sensor_power_on(sensor);
 543         if (ret) {
 544                 dev_err(&pdev->dev, "Error power on sensor: %d\n", ret);
 545                 return ret;
 546         }
 547
 548         sensor->th_dev = devm_thermal_zone_of_sensor_register(&pdev->dev, 0,
 549                                                               sensor,
 550                                                               &stm_tz_ops);
 551
 552         if (IS_ERR(sensor->th_dev)) {
 553                 dev_err(&pdev->dev, "%s: thermal zone sensor registering KO\n",
 554                         __func__);
 555                 ret = PTR_ERR(sensor->th_dev);
 556                 return ret;
 557         }
 558
 559         /* Register IRQ into GIC */
 560         ret = stm_register_irq(sensor);
 561         if (ret)
 562                 goto err_tz;
 563
 564         stm_enable_irq(sensor);
 565
 566         /*
 567          * Thermal_zone doesn't enable hwmon as default,
 568          * enable it here
 569          */
 570         sensor->th_dev->tzp->no_hwmon = false;
 571         ret = thermal_add_hwmon_sysfs(sensor->th_dev);
 572         if (ret)
 573                 goto err_tz;
 574
 575         dev_info(&pdev->dev, "%s: Driver initialized successfully\n",
 576                  __func__);
 577
 578         return 0;
 579
 580 err_tz:
 581         thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
 582         return ret;
 583 }
 584
 585 static int stm_thermal_remove(struct platform_device *pdev)
 586 {
 587         struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
 588
 589         stm_thermal_sensor_off(sensor);
 590         thermal_remove_hwmon_sysfs(sensor->th_dev);
 591         thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
 592
 593         return 0;
 594 }
 595
 596 static struct platform_driver stm_thermal_driver = {
 597         .driver = {
 598                 .name   = "stm_thermal",
 599                 .pm     = &stm_thermal_pm_ops,
 600                 .of_match_table = stm_thermal_of_match,
 601         },
 602         .probe          = stm_thermal_probe,
 603         .remove         = stm_thermal_remove,
 604 };
 605 module_platform_driver(stm_thermal_driver);
 606
 607 MODULE_DESCRIPTION("STMicroelectronics STM32 Thermal Sensor Driver");
 608 MODULE_AUTHOR("David Hernandez Sanchez <david.hernandezsanchez@st.com>");
 609 MODULE_LICENSE("GPL v2");
 610 MODULE_ALIAS("platform:stm_thermal");