LXR linux/drivers/thermal/st/stm

   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
  90struct 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
 102static 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
 125static 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
 142static 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
 175static 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
 200static 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 */
 244static 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
 273static 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 */
 293static 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
 305static 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 */
 353static 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 */
 381static 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                return sensor->irq;
 390
 391        ret = devm_request_threaded_irq(dev, sensor->irq,
 392                                        NULL,
 393                                        stm_thermal_irq_handler,
 394                                        IRQF_ONESHOT,
 395                                        dev->driver->name, sensor);
 396        if (ret) {
 397                dev_err(dev, "%s: Failed to register IRQ %d\n", __func__,
 398                        sensor->irq);
 399                return ret;
 400        }
 401
 402        dev_dbg(dev, "%s: thermal IRQ registered", __func__);
 403
 404        return 0;
 405}
 406
 407static int stm_thermal_sensor_off(struct stm_thermal_sensor *sensor)
 408{
 409        int ret;
 410
 411        stm_disable_irq(sensor);
 412
 413        ret = stm_sensor_power_off(sensor);
 414        if (ret)
 415                return ret;
 416
 417        clk_disable_unprepare(sensor->clk);
 418
 419        return 0;
 420}
 421
 422static int stm_thermal_prepare(struct stm_thermal_sensor *sensor)
 423{
 424        int ret;
 425
 426        ret = clk_prepare_enable(sensor->clk);
 427        if (ret)
 428                return ret;
 429
 430        ret = stm_thermal_read_factory_settings(sensor);
 431        if (ret)
 432                goto thermal_unprepare;
 433
 434        ret = stm_thermal_calibration(sensor);
 435        if (ret)
 436                goto thermal_unprepare;
 437
 438        return 0;
 439
 440thermal_unprepare:
 441        clk_disable_unprepare(sensor->clk);
 442
 443        return ret;
 444}
 445
 446#ifdef CONFIG_PM_SLEEP
 447static int stm_thermal_suspend(struct device *dev)
 448{
 449        struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
 450
 451        return stm_thermal_sensor_off(sensor);
 452}
 453
 454static int stm_thermal_resume(struct device *dev)
 455{
 456        int ret;
 457        struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
 458
 459        ret = stm_thermal_prepare(sensor);
 460        if (ret)
 461                return ret;
 462
 463        ret = stm_sensor_power_on(sensor);
 464        if (ret)
 465                return ret;
 466
 467        thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
 468        stm_enable_irq(sensor);
 469
 470        return 0;
 471}
 472#endif /* CONFIG_PM_SLEEP */
 473
 474static SIMPLE_DEV_PM_OPS(stm_thermal_pm_ops,
 475                         stm_thermal_suspend, stm_thermal_resume);
 476
 477static const struct thermal_zone_of_device_ops stm_tz_ops = {
 478        .get_temp       = stm_thermal_get_temp,
 479        .set_trips      = stm_thermal_set_trips,
 480};
 481
 482static const struct of_device_id stm_thermal_of_match[] = {
 483                { .compatible = "st,stm32-thermal"},
 484        { /* sentinel */ }
 485};
 486MODULE_DEVICE_TABLE(of, stm_thermal_of_match);
 487
 488static int stm_thermal_probe(struct platform_device *pdev)
 489{
 490        struct stm_thermal_sensor *sensor;
 491        struct resource *res;
 492        void __iomem *base;
 493        int ret;
 494
 495        if (!pdev->dev.of_node) {
 496                dev_err(&pdev->dev, "%s: device tree node not found\n",
 497                        __func__);
 498                return -EINVAL;
 499        }
 500
 501        sensor = devm_kzalloc(&pdev->dev, sizeof(*sensor), GFP_KERNEL);
 502        if (!sensor)
 503                return -ENOMEM;
 504
 505        platform_set_drvdata(pdev, sensor);
 506
 507        sensor->dev = &pdev->dev;
 508
 509        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 510        base = devm_ioremap_resource(&pdev->dev, res);
 511        if (IS_ERR(base))
 512                return PTR_ERR(base);
 513
 514        /* Populate sensor */
 515        sensor->base = base;
 516
 517        sensor->clk = devm_clk_get(&pdev->dev, "pclk");
 518        if (IS_ERR(sensor->clk)) {
 519                dev_err(&pdev->dev, "%s: failed to fetch PCLK clock\n",
 520                        __func__);
 521                return PTR_ERR(sensor->clk);
 522        }
 523
 524        stm_disable_irq(sensor);
 525
 526        /* Clear irq flags */
 527        writel_relaxed(ICIFR_MASK, sensor->base + DTS_ICIFR_OFFSET);
 528
 529        /* Configure and enable HW sensor */
 530        ret = stm_thermal_prepare(sensor);
 531        if (ret) {
 532                dev_err(&pdev->dev, "Error prepare sensor: %d\n", ret);
 533                return ret;
 534        }
 535
 536        ret = stm_sensor_power_on(sensor);
 537        if (ret) {
 538                dev_err(&pdev->dev, "Error power on sensor: %d\n", ret);
 539                return ret;
 540        }
 541
 542        sensor->th_dev = devm_thermal_zone_of_sensor_register(&pdev->dev, 0,
 543                                                              sensor,
 544                                                              &stm_tz_ops);
 545
 546        if (IS_ERR(sensor->th_dev)) {
 547                dev_err(&pdev->dev, "%s: thermal zone sensor registering KO\n",
 548                        __func__);
 549                ret = PTR_ERR(sensor->th_dev);
 550                return ret;
 551        }
 552
 553        /* Register IRQ into GIC */
 554        ret = stm_register_irq(sensor);
 555        if (ret)
 556                goto err_tz;
 557
 558        stm_enable_irq(sensor);
 559
 560        /*
 561         * Thermal_zone doesn't enable hwmon as default,
 562         * enable it here
 563         */
 564        sensor->th_dev->tzp->no_hwmon = false;
 565        ret = thermal_add_hwmon_sysfs(sensor->th_dev);
 566        if (ret)
 567                goto err_tz;
 568
 569        dev_info(&pdev->dev, "%s: Driver initialized successfully\n",
 570                 __func__);
 571
 572        return 0;
 573
 574err_tz:
 575        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
 576        return ret;
 577}
 578
 579static int stm_thermal_remove(struct platform_device *pdev)
 580{
 581        struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
 582
 583        stm_thermal_sensor_off(sensor);
 584        thermal_remove_hwmon_sysfs(sensor->th_dev);
 585        thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
 586
 587        return 0;
 588}
 589
 590static struct platform_driver stm_thermal_driver = {
 591        .driver = {
 592                .name   = "stm_thermal",
 593                .pm     = &stm_thermal_pm_ops,
 594                .of_match_table = stm_thermal_of_match,
 595        },
 596        .probe          = stm_thermal_probe,
 597        .remove         = stm_thermal_remove,
 598};
 599module_platform_driver(stm_thermal_driver);
 600
 601MODULE_DESCRIPTION("STMicroelectronics STM32 Thermal Sensor Driver");
 602MODULE_AUTHOR("David Hernandez Sanchez <david.hernandezsanchez@st.com>");
 603MODULE_LICENSE("GPL v2");
 604MODULE_ALIAS("platform:stm_thermal");
 605