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