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