1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
4 * Author: David Hernandez Sanchez <david.hernandezsanchez@st.com> for
9 #include <linux/clk-provider.h>
10 #include <linux/delay.h>
11 #include <linux/err.h>
12 #include <linux/interrupt.h>
14 #include <linux/iopoll.h>
15 #include <linux/module.h>
17 #include <linux/of_address.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 #include <linux/thermal.h>
22 #include "../thermal_core.h"
23 #include "../thermal_hwmon.h"
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_CIFR_OFFSET 0x28
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)
40 /* DTS_T0VALR1 register mask definitions */
41 #define TS1_T0_MASK GENMASK(17, 16)
42 #define TS1_FMT0_MASK GENMASK(15, 0)
44 /* DTS_RAMPVALR register mask definitions */
45 #define TS1_RAMP_COEFF_MASK GENMASK(15, 0)
47 /* DTS_ITR1 register mask definitions */
48 #define TS1_HITTHD_MASK GENMASK(31, 16)
49 #define TS1_LITTHD_MASK GENMASK(15, 0)
51 /* DTS_DR register mask definitions */
52 #define TS1_MFREQ_MASK GENMASK(15, 0)
54 /* Less significant bit position definitions */
56 #define TS1_SMP_TIME_POS 16
57 #define TS1_HITTHD_POS 16
58 #define HSREF_CLK_DIV_POS 24
60 /* DTS_CFGR1 bit definitions */
62 #define TS1_START BIT(4)
63 #define REFCLK_SEL BIT(20)
64 #define REFCLK_LSE REFCLK_SEL
65 #define Q_MEAS_OPT BIT(21)
66 #define CALIBRATION_CONTROL Q_MEAS_OPT
68 /* DTS_SR bit definitions */
69 #define TS_RDY BIT(15)
70 /* Bit definitions below are common for DTS_SR, DTS_ITENR and DTS_CIFR */
71 #define HIGH_THRESHOLD BIT(2)
72 #define LOW_THRESHOLD BIT(1)
76 #define ONE_MHZ 1000000
77 #define POLL_TIMEOUT 5000
78 #define STARTUP_TIME 40
79 #define TS1_T0_VAL0 30
80 #define TS1_T0_VAL1 130
83 /* The Thermal Framework expects millidegrees */
84 #define mcelsius(temp) ((temp) * 1000)
86 /* The Sensor expects oC degrees */
87 #define celsius(temp) ((temp) / 1000)
89 struct stm_thermal_sensor {
91 struct thermal_zone_device *th_dev;
92 enum thermal_device_mode mode;
98 unsigned int low_temp_enabled;
101 unsigned int irq_enabled;
103 int t0, fmt0, ramp_coeff;
106 static irqreturn_t stm_thermal_alarm_irq(int irq, void *sdata)
108 struct stm_thermal_sensor *sensor = sdata;
110 disable_irq_nosync(irq);
111 sensor->irq_enabled = false;
113 return IRQ_WAKE_THREAD;
116 static irqreturn_t stm_thermal_alarm_irq_thread(int irq, void *sdata)
119 struct stm_thermal_sensor *sensor = sdata;
121 /* read IT reason in SR and clear flags */
122 value = readl_relaxed(sensor->base + DTS_SR_OFFSET);
124 if ((value & LOW_THRESHOLD) == LOW_THRESHOLD)
125 writel_relaxed(LOW_THRESHOLD, sensor->base + DTS_CIFR_OFFSET);
127 if ((value & HIGH_THRESHOLD) == HIGH_THRESHOLD)
128 writel_relaxed(HIGH_THRESHOLD, sensor->base + DTS_CIFR_OFFSET);
130 thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
135 static int stm_sensor_power_on(struct stm_thermal_sensor *sensor)
141 value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
143 writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
146 * The DTS block can be enabled by setting TSx_EN bit in
147 * DTS_CFGRx register. It requires a startup time of
148 * 40μs. Use 5 ms as arbitrary timeout.
150 ret = readl_poll_timeout(sensor->base + DTS_SR_OFFSET,
151 value, (value & TS_RDY),
152 STARTUP_TIME, POLL_TIMEOUT);
156 /* Start continuous measuring */
157 value = readl_relaxed(sensor->base +
160 writel_relaxed(value, sensor->base +
166 static int stm_sensor_power_off(struct stm_thermal_sensor *sensor)
171 value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
173 writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
175 /* Ensure stop is taken into account */
176 usleep_range(STARTUP_TIME, POLL_TIMEOUT);
179 value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
181 writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
183 /* Ensure disable is taken into account */
184 return readl_poll_timeout(sensor->base + DTS_SR_OFFSET, value,
186 STARTUP_TIME, POLL_TIMEOUT);
189 static int stm_thermal_calibration(struct stm_thermal_sensor *sensor)
194 /* Figure out prescaler value for PCLK during calibration */
195 clk_freq = clk_get_rate(sensor->clk);
202 while (prescaler <= clk_freq)
206 value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
208 /* Clear prescaler */
209 value &= ~HSREF_CLK_DIV_MASK;
211 /* Set prescaler. pclk_freq/prescaler < 1MHz */
212 value |= (prescaler << HSREF_CLK_DIV_POS);
214 /* Select PCLK as reference clock */
215 value &= ~REFCLK_SEL;
217 /* Set maximal sampling time for better precision */
218 value |= TS1_SMP_TIME_MASK;
220 /* Measure with calibration */
221 value &= ~CALIBRATION_CONTROL;
224 value &= ~TS1_INTRIG_SEL_MASK;
227 writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
232 /* Fill in DTS structure with factory sensor values */
233 static int stm_thermal_read_factory_settings(struct stm_thermal_sensor *sensor)
235 /* Retrieve engineering calibration temperature */
236 sensor->t0 = readl_relaxed(sensor->base + DTS_T0VALR1_OFFSET) &
239 sensor->t0 = TS1_T0_VAL0;
241 sensor->t0 = TS1_T0_VAL1;
243 /* Retrieve fmt0 and put it on Hz */
244 sensor->fmt0 = ADJUST * readl_relaxed(sensor->base + DTS_T0VALR1_OFFSET)
247 /* Retrieve ramp coefficient */
248 sensor->ramp_coeff = readl_relaxed(sensor->base + DTS_RAMPVALR_OFFSET) &
251 if (!sensor->fmt0 || !sensor->ramp_coeff) {
252 dev_err(sensor->dev, "%s: wrong setting\n", __func__);
256 dev_dbg(sensor->dev, "%s: T0 = %doC, FMT0 = %dHz, RAMP_COEFF = %dHz/oC",
257 __func__, sensor->t0, sensor->fmt0, sensor->ramp_coeff);
262 static int stm_thermal_calculate_threshold(struct stm_thermal_sensor *sensor,
268 /* Retrieve the number of periods to sample */
269 sampling_time = (readl_relaxed(sensor->base + DTS_CFGR1_OFFSET) &
270 TS1_SMP_TIME_MASK) >> TS1_SMP_TIME_POS;
272 /* Figure out the CLK_PTAT frequency for a given temperature */
273 freqM = ((temp - sensor->t0) * sensor->ramp_coeff)
276 dev_dbg(sensor->dev, "%s: freqM for threshold = %d Hz",
279 /* Figure out the threshold sample number */
280 *th = clk_get_rate(sensor->clk);
286 *th *= sampling_time;
291 static int stm_thermal_set_threshold(struct stm_thermal_sensor *sensor)
296 value = readl_relaxed(sensor->base + DTS_ITR1_OFFSET);
298 /* Erase threshold content */
299 value &= ~(TS1_LITTHD_MASK | TS1_HITTHD_MASK);
301 /* Retrieve the sample threshold number th for a given temperature */
302 ret = stm_thermal_calculate_threshold(sensor, sensor->high_temp, &th);
306 value |= th & TS1_LITTHD_MASK;
308 if (sensor->low_temp_enabled) {
309 /* Retrieve the sample threshold */
310 ret = stm_thermal_calculate_threshold(sensor, sensor->low_temp,
315 value |= (TS1_HITTHD_MASK & (th << TS1_HITTHD_POS));
318 /* Write value on the Low interrupt threshold */
319 writel_relaxed(value, sensor->base + DTS_ITR1_OFFSET);
324 /* Disable temperature interrupt */
325 static int stm_disable_irq(struct stm_thermal_sensor *sensor)
329 /* Disable IT generation for low and high thresholds */
330 value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
331 writel_relaxed(value & ~(LOW_THRESHOLD | HIGH_THRESHOLD),
332 sensor->base + DTS_ITENR_OFFSET);
334 dev_dbg(sensor->dev, "%s: IT disabled on sensor side", __func__);
339 /* Enable temperature interrupt */
340 static int stm_enable_irq(struct stm_thermal_sensor *sensor)
345 * Code below enables High temperature threshold using a low threshold
349 /* Make sure LOW_THRESHOLD IT is clear before enabling */
350 writel_relaxed(LOW_THRESHOLD, sensor->base + DTS_CIFR_OFFSET);
352 /* Enable IT generation for low threshold */
353 value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
354 value |= LOW_THRESHOLD;
356 /* Enable the low temperature threshold if needed */
357 if (sensor->low_temp_enabled) {
358 /* Make sure HIGH_THRESHOLD IT is clear before enabling */
359 writel_relaxed(HIGH_THRESHOLD, sensor->base + DTS_CIFR_OFFSET);
361 /* Enable IT generation for high threshold */
362 value |= HIGH_THRESHOLD;
365 /* Enable thresholds */
366 writel_relaxed(value, sensor->base + DTS_ITENR_OFFSET);
368 dev_dbg(sensor->dev, "%s: IT enabled on sensor side", __func__);
373 static int stm_thermal_update_threshold(struct stm_thermal_sensor *sensor)
377 sensor->mode = THERMAL_DEVICE_DISABLED;
379 ret = stm_sensor_power_off(sensor);
383 ret = stm_disable_irq(sensor);
387 ret = stm_thermal_set_threshold(sensor);
391 ret = stm_enable_irq(sensor);
395 ret = stm_sensor_power_on(sensor);
399 sensor->mode = THERMAL_DEVICE_ENABLED;
404 /* Callback to get temperature from HW */
405 static int stm_thermal_get_temp(void *data, int *temp)
407 struct stm_thermal_sensor *sensor = data;
411 if (sensor->mode != THERMAL_DEVICE_ENABLED)
414 /* Retrieve the number of samples */
415 ret = readl_poll_timeout(sensor->base + DTS_DR_OFFSET, freqM,
416 (freqM & TS1_MFREQ_MASK), STARTUP_TIME,
425 /* Retrieve the number of periods sampled */
426 sampling_time = (readl_relaxed(sensor->base + DTS_CFGR1_OFFSET) &
427 TS1_SMP_TIME_MASK) >> TS1_SMP_TIME_POS;
429 /* Figure out the number of samples per period */
430 freqM /= sampling_time;
432 /* Figure out the CLK_PTAT frequency */
433 freqM = clk_get_rate(sensor->clk) / freqM;
437 dev_dbg(sensor->dev, "%s: freqM=%d\n", __func__, freqM);
439 /* Figure out the temperature in mili celsius */
440 *temp = mcelsius(sensor->t0 + ((freqM - sensor->fmt0) /
441 sensor->ramp_coeff));
443 dev_dbg(sensor->dev, "%s: temperature = %d millicelsius",
446 /* Update thresholds */
447 if (sensor->num_trips > 1) {
448 /* Update alarm threshold value to next higher trip point */
449 if (sensor->high_temp == sensor->temp_passive &&
450 celsius(*temp) >= sensor->temp_passive) {
451 sensor->high_temp = sensor->temp_critical;
452 sensor->low_temp = sensor->temp_passive;
453 sensor->low_temp_enabled = true;
454 ret = stm_thermal_update_threshold(sensor);
459 if (sensor->high_temp == sensor->temp_critical &&
460 celsius(*temp) < sensor->temp_passive) {
461 sensor->high_temp = sensor->temp_passive;
462 sensor->low_temp_enabled = false;
463 ret = stm_thermal_update_threshold(sensor);
469 * Re-enable alarm IRQ if temperature below critical
472 if (!sensor->irq_enabled &&
473 (celsius(*temp) < sensor->temp_critical)) {
474 sensor->irq_enabled = true;
475 enable_irq(sensor->irq);
482 /* Registers DTS irq to be visible by GIC */
483 static int stm_register_irq(struct stm_thermal_sensor *sensor)
485 struct device *dev = sensor->dev;
486 struct platform_device *pdev = to_platform_device(dev);
489 sensor->irq = platform_get_irq(pdev, 0);
490 if (sensor->irq < 0) {
491 dev_err(dev, "%s: Unable to find IRQ\n", __func__);
495 ret = devm_request_threaded_irq(dev, sensor->irq,
496 stm_thermal_alarm_irq,
497 stm_thermal_alarm_irq_thread,
499 dev->driver->name, sensor);
501 dev_err(dev, "%s: Failed to register IRQ %d\n", __func__,
506 sensor->irq_enabled = true;
508 dev_dbg(dev, "%s: thermal IRQ registered", __func__);
513 static int stm_thermal_sensor_off(struct stm_thermal_sensor *sensor)
517 ret = stm_sensor_power_off(sensor);
521 clk_disable_unprepare(sensor->clk);
526 static int stm_thermal_prepare(struct stm_thermal_sensor *sensor)
529 struct device *dev = sensor->dev;
531 ret = clk_prepare_enable(sensor->clk);
535 ret = stm_thermal_read_factory_settings(sensor);
537 goto thermal_unprepare;
539 ret = stm_thermal_calibration(sensor);
541 goto thermal_unprepare;
543 /* Set threshold(s) for IRQ */
544 ret = stm_thermal_set_threshold(sensor);
546 goto thermal_unprepare;
548 ret = stm_enable_irq(sensor);
550 goto thermal_unprepare;
552 ret = stm_sensor_power_on(sensor);
554 dev_err(dev, "%s: failed to power on sensor\n", __func__);
561 stm_disable_irq(sensor);
564 clk_disable_unprepare(sensor->clk);
569 #ifdef CONFIG_PM_SLEEP
570 static int stm_thermal_suspend(struct device *dev)
573 struct platform_device *pdev = to_platform_device(dev);
574 struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
576 ret = stm_thermal_sensor_off(sensor);
580 sensor->mode = THERMAL_DEVICE_DISABLED;
585 static int stm_thermal_resume(struct device *dev)
588 struct platform_device *pdev = to_platform_device(dev);
589 struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
591 ret = stm_thermal_prepare(sensor);
595 sensor->mode = THERMAL_DEVICE_ENABLED;
599 #endif /* CONFIG_PM_SLEEP */
601 SIMPLE_DEV_PM_OPS(stm_thermal_pm_ops, stm_thermal_suspend, stm_thermal_resume);
603 static const struct thermal_zone_of_device_ops stm_tz_ops = {
604 .get_temp = stm_thermal_get_temp,
607 static const struct of_device_id stm_thermal_of_match[] = {
608 { .compatible = "st,stm32-thermal"},
611 MODULE_DEVICE_TABLE(of, stm_thermal_of_match);
613 static int stm_thermal_probe(struct platform_device *pdev)
615 struct stm_thermal_sensor *sensor;
616 struct resource *res;
617 const struct thermal_trip *trip;
621 if (!pdev->dev.of_node) {
622 dev_err(&pdev->dev, "%s: device tree node not found\n",
627 sensor = devm_kzalloc(&pdev->dev, sizeof(*sensor), GFP_KERNEL);
631 platform_set_drvdata(pdev, sensor);
633 sensor->dev = &pdev->dev;
635 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
636 base = devm_ioremap_resource(&pdev->dev, res);
638 return PTR_ERR(base);
640 /* Populate sensor */
643 sensor->clk = devm_clk_get(&pdev->dev, "pclk");
644 if (IS_ERR(sensor->clk)) {
645 dev_err(&pdev->dev, "%s: failed to fetch PCLK clock\n",
647 return PTR_ERR(sensor->clk);
650 /* Register IRQ into GIC */
651 ret = stm_register_irq(sensor);
655 sensor->th_dev = devm_thermal_zone_of_sensor_register(&pdev->dev, 0,
659 if (IS_ERR(sensor->th_dev)) {
660 dev_err(&pdev->dev, "%s: thermal zone sensor registering KO\n",
662 ret = PTR_ERR(sensor->th_dev);
666 if (!sensor->th_dev->ops->get_crit_temp) {
667 /* Critical point must be provided */
672 ret = sensor->th_dev->ops->get_crit_temp(sensor->th_dev,
673 &sensor->temp_critical);
676 "Not able to read critical_temp: %d\n", ret);
680 sensor->temp_critical = celsius(sensor->temp_critical);
682 /* Set thresholds for IRQ */
683 sensor->high_temp = sensor->temp_critical;
685 trip = of_thermal_get_trip_points(sensor->th_dev);
686 sensor->num_trips = of_thermal_get_ntrips(sensor->th_dev);
688 /* Find out passive temperature if it exists */
689 for (i = (sensor->num_trips - 1); i >= 0; i--) {
690 if (trip[i].type == THERMAL_TRIP_PASSIVE) {
691 sensor->temp_passive = celsius(trip[i].temperature);
692 /* Update high temperature threshold */
693 sensor->high_temp = sensor->temp_passive;
698 * Ensure low_temp_enabled flag is disabled.
699 * By disabling low_temp_enabled, low threshold IT will not be
700 * configured neither enabled because it is not needed as high
701 * threshold is set on the lowest temperature trip point after
704 sensor->low_temp_enabled = false;
706 /* Configure and enable HW sensor */
707 ret = stm_thermal_prepare(sensor);
710 "Not able to enable sensor: %d\n", ret);
715 * Thermal_zone doesn't enable hwmon as default,
718 sensor->th_dev->tzp->no_hwmon = false;
719 ret = thermal_add_hwmon_sysfs(sensor->th_dev);
723 sensor->mode = THERMAL_DEVICE_ENABLED;
725 dev_info(&pdev->dev, "%s: Driver initialized successfully\n",
731 thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
735 static int stm_thermal_remove(struct platform_device *pdev)
737 struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
739 stm_thermal_sensor_off(sensor);
740 thermal_remove_hwmon_sysfs(sensor->th_dev);
741 thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
746 static struct platform_driver stm_thermal_driver = {
748 .name = "stm_thermal",
749 .pm = &stm_thermal_pm_ops,
750 .of_match_table = stm_thermal_of_match,
752 .probe = stm_thermal_probe,
753 .remove = stm_thermal_remove,
755 module_platform_driver(stm_thermal_driver);
757 MODULE_DESCRIPTION("STMicroelectronics STM32 Thermal Sensor Driver");
758 MODULE_AUTHOR("David Hernandez Sanchez <david.hernandezsanchez@st.com>");
759 MODULE_LICENSE("GPL v2");
760 MODULE_ALIAS("platform:stm_thermal");